+ These files are for the standalone release, meant for inclusion on a static HTML page and manual management of files.
+
+
+ For a using Jasmine with Ruby on Rails, other Ruby frameworks, within continuous integration environments, or to gain more dynamic source and test file loading, see
+ Using the Jasmine Gem
+ .
+
+
+
+ Powered by
+
+
+
+
diff --git a/pages/downloads/jasmine-standalone-0.11.1.zip b/pages/downloads/jasmine-standalone-0.11.1.zip
new file mode 100644
index 0000000..ab92663
Binary files /dev/null and b/pages/downloads/jasmine-standalone-0.11.1.zip differ
diff --git a/pages/downloads/jasmine-standalone-1.0.0.rc1.zip b/pages/downloads/jasmine-standalone-1.0.0.rc1.zip
new file mode 100644
index 0000000..553e41c
Binary files /dev/null and b/pages/downloads/jasmine-standalone-1.0.0.rc1.zip differ
diff --git a/pages/downloads/jasmine-standalone-1.0.0.zip b/pages/downloads/jasmine-standalone-1.0.0.zip
new file mode 100644
index 0000000..f46fdf7
Binary files /dev/null and b/pages/downloads/jasmine-standalone-1.0.0.zip differ
diff --git a/pages/downloads/jasmine-standalone-1.0.1.zip b/pages/downloads/jasmine-standalone-1.0.1.zip
new file mode 100644
index 0000000..9127103
Binary files /dev/null and b/pages/downloads/jasmine-standalone-1.0.1.zip differ
diff --git a/pages/downloads/jasmine-standalone-1.0.2.zip b/pages/downloads/jasmine-standalone-1.0.2.zip
new file mode 100644
index 0000000..bce3d0c
Binary files /dev/null and b/pages/downloads/jasmine-standalone-1.0.2.zip differ
diff --git a/pages/favicon.ico b/pages/favicon.ico
new file mode 100644
index 0000000..e69de29
diff --git a/pages/fonts/droidsans-bold.ttf b/pages/fonts/droidsans-bold.ttf
new file mode 100644
index 0000000..7ac04b6
Binary files /dev/null and b/pages/fonts/droidsans-bold.ttf differ
diff --git a/pages/fonts/droidsans.ttf b/pages/fonts/droidsans.ttf
new file mode 100644
index 0000000..767c63a
Binary files /dev/null and b/pages/fonts/droidsans.ttf differ
diff --git a/pages/fonts/inconsolata.otf b/pages/fonts/inconsolata.otf
new file mode 100644
index 0000000..3488898
Binary files /dev/null and b/pages/fonts/inconsolata.otf differ
diff --git a/pages/images/jasmine_logo.png b/pages/images/jasmine_logo.png
new file mode 100644
index 0000000..9ffc5a0
Binary files /dev/null and b/pages/images/jasmine_logo.png differ
diff --git a/pages/images/pivotal_logo.gif b/pages/images/pivotal_logo.gif
new file mode 100644
index 0000000..9306043
Binary files /dev/null and b/pages/images/pivotal_logo.gif differ
diff --git a/pages/index.html b/pages/index.html
new file mode 100644
index 0000000..e5563f9
--- /dev/null
+++ b/pages/index.html
@@ -0,0 +1,79 @@
+
+
+
+
+ Jasmine: BDD for your JavaScript
+
+
+
+
+
+
+
+
+
+
BDD for JavaScript
+
+
+
+ Jasmine is a behavior-driven development framework for testing your JavaScript code. It does not depend on any other
+ JavaScript frameworks. It does not require a DOM. And it has a clean, obvious syntax so that you can easily write tests.
+
+ Jasmine can be run anywhere you can execute JavaScript: a static web page, your continuous integration environment,
+ or server-side environments like
+ Node.js
+ .
+
+ A function that is called after each spec in a suite.
+
+Used for restoring any state that is hijacked during spec execution.
+
+
+ Defined in: base.js.
+
+
+
+
+
+
+
+
+
Parameters:
+
+
+ {Function}afterEachFunction
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ beforeEach(beforeEachFunction)
+
+
+
+ A function that is called before each spec in a suite.
+
+Used for spec setup, including validating assumptions.
+
+
+ Defined in: base.js.
+
+
+
+ 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.
+
+
+ Defined in: base.js.
+
+
+
+
+
+
+
// TODO: a simple suite
+
+// TODO: a simple suite with a nested describe block
+
+
+
+
+
+
Parameters:
+
+
+ {String}description
+
+
+
A string, usually the class under test.
+
+
+ {Function}specDefinitions
+
+
+
function that defines several specs.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ expect(actual)
+
+
+
+ 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.
+
+
+ Defined in: base.js.
+
+
+
+
+
+
+
+
+
Parameters:
+
+
+ {Object}actual
+
+
+
Actual value to test against and expected value
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ it(desc, func)
+
+
+
+ Creates a Jasmine spec that will be added to the current suite.
+
+// TODO: pending tests
+
+
+ Defined in: base.js.
+
+
+
+
+
+
+
it('should be true', function() {
+ expect(true).toEqual(true);
+});
+
+
+
+
+
+
Parameters:
+
+
+ {String}desc
+
+
+
description of this specification
+
+
+ {Function}func
+
+
+
defines the preconditions and expectations of the spec
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ runs(func)
+
+
+
+ Defines part of a jasmine spec. Used in cominbination with waits or waitsFor in asynchrnous specs.
+
+
+ Defined in: base.js.
+
+
+
+ Waits for the latchFunction to return true before proceeding to the next block.
+
+
+ Defined in: base.js.
+
+
+
+
+
+
+
+
+
Parameters:
+
+
+ {Function}latchFunction
+
+
+
+
+
+ {String}optional_timeoutMessage
+
+
+
+
+
+ {Number}optional_timeout
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ xdescribe(description, specDefinitions)
+
+
+
+ Disables a suite of specifications. Used to disable some suites in a file, or files, temporarily during development.
+
+
+ Defined in: base.js.
+
+
+
+
+
+
+
+
+
Parameters:
+
+
+ {String}description
+
+
+
A string, usually the class under test.
+
+
+ {Function}specDefinitions
+
+
+
function that defines several specs.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ xit(desc, func)
+
+
+
+ Creates a disabled Jasmine spec.
+
+A convenience method that allows existing specs to be disabled temporarily during development.
+
+
+ Defined in: base.js.
+
+
+
+
+
+
+
+
+
Parameters:
+
+
+ {String}desc
+
+
+
description of this specification
+
+
+ {Function}func
+
+
+
defines the preconditions and expectations of the spec
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Documentation generated by JsDoc Toolkit 2.1.0 on Sun Feb 27 2011 12:17:44 GMT-0800 (PST)
+
+ All parameters are pretty-printed and concatenated together, then written to the spec's output.
+
+Be careful not to leave calls to jasmine.log in production code.
+
+
+
Resets all of a spy's the tracking variables so that it can be used again.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Class Detail
+
+
+
+ jasmine.Spy(name)
+
+
+
+ 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 fields: wasCalled, callCount, mostRecentCall, and argsForCall (see docs).
+
+Spies are torn down at the end of every spec.
+
+Note: Do not call new jasmine.Spy() directly - a spy must be created using spyOn, jasmine.createSpy or jasmine.createSpyObj.
+
+
+
+
+
+
// 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).toHaveBeenCalled();
+expect(foo.not).toHaveBeenCalledWith(true);
+ Tracking of the most recent call to the spy.
+
+
+
+
+
+
+
var mySpy = jasmine.createSpy('foo');
+mySpy(1, 2);
+mySpy.mostRecentCall.args = [1, 2];
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Method Detail
+
+
+
+
+
+
+ andCallFake(fakeFunc)
+
+
+
+ Calls an alternate implementation when a spy is called.
+
+
+
+
+
+
+
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';} );
+
+
+
+
+
+
Parameters:
+
+
+ {Function}fakeFunc
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ andCallThrough()
+
+
+
+ Tells a spy to call through to the actual implemenatation.
+
+
+
+
+
+
+
var foo = {
+ bar: function() { // do some stuff }
+}
+
+// defining a spy on an existing property: foo.bar
+spyOn(foo, 'bar').andCallThrough();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ andReturn(value)
+
+
+
+ For setting the return value of a spy.
+
+
+
+
+
+
+
// 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');
+
+
+
+
+
+
Parameters:
+
+
+ {Object}value
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ andThrow(exceptionMsg)
+
+
+
+ For throwing an exception when a spy is called.
+
+
+
+
+
+
+
// 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');
+
+
+
+
+
+
Parameters:
+
+
+ {String}exceptionMsg
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ plan()
+
+
+
+ The actual function this spy stubs.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ reset()
+
+
+
+ Resets all of a spy's the tracking variables so that it can be used again.
+
+
+
+ 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.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Method Detail
+
+
+
+
<static>
+
+
+ jasmine.any(clazz)
+
+
+
+ Returns a matchable 'generic' object of the class type. For use in expecations of type when values don't matter.
+
+
+
+
+
+
+
// don't care about which function is passed in, as long as it's a function
+expect(mySpy).toHaveBeenCalledWith(jasmine.any(Function));
+ All parameters are pretty-printed and concatenated together, then written to the current spec's output.
+
+Be careful not to leave calls to jasmine.log in production code.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
<static>
+
+
+ jasmine.MessageResult(values)
+
+
+
+
+
+
+
+
+
+
+
+
+
Parameters:
+
+
+ values
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
<static>
+
+ {String}
+ jasmine.pp(value)
+
+
+
+ Pretty printer for expecations. Takes any object and turns it into a human-readable string.
+
+
+
+
+
+
+
+
+
Parameters:
+
+
+ value
+
+
+
{Object} an object to be outputted
+
+
+
+
+
+
+
+
+
Returns:
+
+
{String}
+
+
+
+
+
+
+
+
+
+
<static>
+
+
+ jasmine.PrettyPrinter()
+
+
+
+ Base class for pretty printing for expectation results.
+
+
+ Defined in: PrettyPrinter.js.
+
+
+
\ No newline at end of file
diff --git a/pages/jsdoc/symbols/src/src_Env.js.html b/pages/jsdoc/symbols/src/src_Env.js.html
new file mode 100644
index 0000000..bdcf2ef
--- /dev/null
+++ b/pages/jsdoc/symbols/src/src_Env.js.html
@@ -0,0 +1,272 @@
+
\ No newline at end of file
diff --git a/pages/jsdoc/symbols/src/src_JsApiReporter.js.html b/pages/jsdoc/symbols/src/src_JsApiReporter.js.html
new file mode 100644
index 0000000..8ba33ff
--- /dev/null
+++ b/pages/jsdoc/symbols/src/src_JsApiReporter.js.html
@@ -0,0 +1,110 @@
+
\ No newline at end of file
diff --git a/pages/jsdoc/symbols/src/src_Matchers.js.html b/pages/jsdoc/symbols/src/src_Matchers.js.html
new file mode 100644
index 0000000..ab3d5fb
--- /dev/null
+++ b/pages/jsdoc/symbols/src/src_Matchers.js.html
@@ -0,0 +1,362 @@
+
1/**
+ 2 * @constructor
+ 3 * @param {jasmine.Env} env
+ 4 * @param actual
+ 5 * @param {jasmine.Spec} spec
+ 6 */
+ 7jasmine.Matchers=function(env,actual,spec,opt_isNot){
+ 8this.env=env;
+ 9this.actual=actual;
+ 10this.spec=spec;
+ 11this.isNot=opt_isNot||false;
+ 12this.reportWasCalled_=false;
+ 13};
+ 14
+ 15// todo: @deprecated as of Jasmine 0.11, remove soon [xw]
+ 16jasmine.Matchers.pp=function(str){
+ 17thrownewError("jasmine.Matchers.pp() is no longer supported, please use jasmine.pp() instead!");
+ 18};
+ 19
+ 20// todo: @deprecated Deprecated as of Jasmine 0.10. Rewrite your custom matchers to return true or false. [xw]
+ 21jasmine.Matchers.prototype.report=function(result,failing_message,details){
+ 22thrownewError("As of jasmine 0.11, custom matchers must be implemented differently -- please see jasmine docs");
+ 23};
+ 24
+ 25jasmine.Matchers.wrapInto_=function(prototype,matchersClass){
+ 26for(varmethodNameinprototype){
+ 27if(methodName=='report')continue;
+ 28varorig=prototype[methodName];
+ 29matchersClass.prototype[methodName]=jasmine.Matchers.matcherFn_(methodName,orig);
+ 30}
+ 31};
+ 32
+ 33jasmine.Matchers.matcherFn_=function(matcherName,matcherFunction){
+ 34returnfunction(){
+ 35varmatcherArgs=jasmine.util.argsToArray(arguments);
+ 36varresult=matcherFunction.apply(this,arguments);
+ 37
+ 38if(this.isNot){
+ 39result=!result;
+ 40}
+ 41
+ 42if(this.reportWasCalled_)returnresult;
+ 43
+ 44varmessage;
+ 45if(!result){
+ 46if(this.message){
+ 47message=this.message.apply(this,arguments);
+ 48if(jasmine.isArray_(message)){
+ 49message=message[this.isNot?1:0];
+ 50}
+ 51}else{
+ 52varenglishyPredicate=matcherName.replace(/[A-Z]/g,function(s){return' '+s.toLowerCase();});
+ 53message="Expected "+jasmine.pp(this.actual)+(this.isNot?" not ":" ")+englishyPredicate;
+ 54if(matcherArgs.length>0){
+ 55for(vari=0;i<matcherArgs.length;i++){
+ 56if(i>0)message+=",";
+ 57message+=" "+jasmine.pp(matcherArgs[i]);
+ 58}
+ 59}
+ 60message+=".";
+ 61}
+ 62}
+ 63varexpectationResult=newjasmine.ExpectationResult({
+ 64matcherName:matcherName,
+ 65passed:result,
+ 66expected:matcherArgs.length>1?matcherArgs:matcherArgs[0],
+ 67actual:this.actual,
+ 68message:message
+ 69});
+ 70this.spec.addMatcherResult(expectationResult);
+ 71returnjasmine.undefined;
+ 72};
+ 73};
+ 74
+ 75
+ 76
+ 77
+ 78/**
+ 79 * toBe: compares the actual to the expected using ===
+ 80 * @param expected
+ 81 */
+ 82jasmine.Matchers.prototype.toBe=function(expected){
+ 83returnthis.actual===expected;
+ 84};
+ 85
+ 86/**
+ 87 * toNotBe: compares the actual to the expected using !==
+ 88 * @param expected
+ 89 * @deprecated as of 1.0. Use not.toBe() instead.
+ 90 */
+ 91jasmine.Matchers.prototype.toNotBe=function(expected){
+ 92returnthis.actual!==expected;
+ 93};
+ 94
+ 95/**
+ 96 * toEqual: compares the actual to the expected using common sense equality. Handles Objects, Arrays, etc.
+ 97 *
+ 98 * @param expected
+ 99 */
+100jasmine.Matchers.prototype.toEqual=function(expected){
+101returnthis.env.equals_(this.actual,expected);
+102};
+103
+104/**
+105 * toNotEqual: compares the actual to the expected using the ! of jasmine.Matchers.toEqual
+106 * @param expected
+107 * @deprecated as of 1.0. Use not.toNotEqual() instead.
+108 */
+109jasmine.Matchers.prototype.toNotEqual=function(expected){
+110return!this.env.equals_(this.actual,expected);
+111};
+112
+113/**
+114 * Matcher that compares the actual to the expected using a regular expression. Constructs a RegExp, so takes
+115 * a pattern or a String.
+116 *
+117 * @param expected
+118 */
+119jasmine.Matchers.prototype.toMatch=function(expected){
+120returnnewRegExp(expected).test(this.actual);
+121};
+122
+123/**
+124 * Matcher that compares the actual to the expected using the boolean inverse of jasmine.Matchers.toMatch
+125 * @param expected
+126 * @deprecated as of 1.0. Use not.toMatch() instead.
+127 */
+128jasmine.Matchers.prototype.toNotMatch=function(expected){
+129return!(newRegExp(expected).test(this.actual));
+130};
+131
+132/**
+133 * Matcher that compares the actual to jasmine.undefined.
+134 */
+135jasmine.Matchers.prototype.toBeDefined=function(){
+136return(this.actual!==jasmine.undefined);
+137};
+138
+139/**
+140 * Matcher that compares the actual to jasmine.undefined.
+141 */
+142jasmine.Matchers.prototype.toBeUndefined=function(){
+143return(this.actual===jasmine.undefined);
+144};
+145
+146/**
+147 * Matcher that compares the actual to null.
+148 */
+149jasmine.Matchers.prototype.toBeNull=function(){
+150return(this.actual===null);
+151};
+152
+153/**
+154 * Matcher that boolean not-nots the actual.
+155 */
+156jasmine.Matchers.prototype.toBeTruthy=function(){
+157return!!this.actual;
+158};
+159
+160
+161/**
+162 * Matcher that boolean nots the actual.
+163 */
+164jasmine.Matchers.prototype.toBeFalsy=function(){
+165return!this.actual;
+166};
+167
+168
+169/**
+170 * Matcher that checks to see if the actual, a Jasmine spy, was called.
+171 */
+172jasmine.Matchers.prototype.toHaveBeenCalled=function(){
+173if(arguments.length>0){
+174thrownewError('toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith');
+175}
+176
+177if(!jasmine.isSpy(this.actual)){
+178thrownewError('Expected a spy, but got '+jasmine.pp(this.actual)+'.');
+179}
+180
+181this.message=function(){
+182return[
+183"Expected spy "+this.actual.identity+" to have been called.",
+184"Expected spy "+this.actual.identity+" not to have been called."
+185];
+186};
+187
+188returnthis.actual.wasCalled;
+189};
+190
+191/** @deprecated Use expect(xxx).toHaveBeenCalled() instead */
+192jasmine.Matchers.prototype.wasCalled=jasmine.Matchers.prototype.toHaveBeenCalled;
+193
+194/**
+195 * Matcher that checks to see if the actual, a Jasmine spy, was not called.
+196 *
+197 * @deprecated Use expect(xxx).not.toHaveBeenCalled() instead
+198 */
+199jasmine.Matchers.prototype.wasNotCalled=function(){
+200if(arguments.length>0){
+201thrownewError('wasNotCalled does not take arguments');
+202}
+203
+204if(!jasmine.isSpy(this.actual)){
+205thrownewError('Expected a spy, but got '+jasmine.pp(this.actual)+'.');
+206}
+207
+208this.message=function(){
+209return[
+210"Expected spy "+this.actual.identity+" to not have been called.",
+211"Expected spy "+this.actual.identity+" to have been called."
+212];
+213};
+214
+215return!this.actual.wasCalled;
+216};
+217
+218/**
+219 * Matcher that checks to see if the actual, a Jasmine spy, was called with a set of parameters.
+220 *
+221 * @example
+222 *
+223 */
+224jasmine.Matchers.prototype.toHaveBeenCalledWith=function(){
+225varexpectedArgs=jasmine.util.argsToArray(arguments);
+226if(!jasmine.isSpy(this.actual)){
+227thrownewError('Expected a spy, but got '+jasmine.pp(this.actual)+'.');
+228}
+229this.message=function(){
+230if(this.actual.callCount==0){
+231// todo: what should the failure message for .not.toHaveBeenCalledWith() be? is this right? test better. [xw]
+232return[
+233"Expected spy to have been called with "+jasmine.pp(expectedArgs)+" but it was never called.",
+234"Expected spy not to have been called with "+jasmine.pp(expectedArgs)+" but it was."
+235];
+236}else{
+237return[
+238"Expected spy to have been called with "+jasmine.pp(expectedArgs)+" but was called with "+jasmine.pp(this.actual.argsForCall),
+239"Expected spy not to have been called with "+jasmine.pp(expectedArgs)+" but was called with "+jasmine.pp(this.actual.argsForCall)
+240];
+241}
+242};
+243
+244returnthis.env.contains_(this.actual.argsForCall,expectedArgs);
+245};
+246
+247/** @deprecated Use expect(xxx).toHaveBeenCalledWith() instead */
+248jasmine.Matchers.prototype.wasCalledWith=jasmine.Matchers.prototype.toHaveBeenCalledWith;
+249
+250/** @deprecated Use expect(xxx).not.toHaveBeenCalledWith() instead */
+251jasmine.Matchers.prototype.wasNotCalledWith=function(){
+252varexpectedArgs=jasmine.util.argsToArray(arguments);
+253if(!jasmine.isSpy(this.actual)){
+254thrownewError('Expected a spy, but got '+jasmine.pp(this.actual)+'.');
+255}
+256
+257this.message=function(){
+258return[
+259"Expected spy not to have been called with "+jasmine.pp(expectedArgs)+" but it was",
+260"Expected spy to have been called with "+jasmine.pp(expectedArgs)+" but it was"
+261]
+262};
+263
+264return!this.env.contains_(this.actual.argsForCall,expectedArgs);
+265};
+266
+267/**
+268 * Matcher that checks that the expected item is an element in the actual Array.
+269 *
+270 * @param {Object} expected
+271 */
+272jasmine.Matchers.prototype.toContain=function(expected){
+273returnthis.env.contains_(this.actual,expected);
+274};
+275
+276/**
+277 * Matcher that checks that the expected item is NOT an element in the actual Array.
+278 *
+279 * @param {Object} expected
+280 * @deprecated as of 1.0. Use not.toNotContain() instead.
+281 */
+282jasmine.Matchers.prototype.toNotContain=function(expected){
+283return!this.env.contains_(this.actual,expected);
+284};
+285
+286jasmine.Matchers.prototype.toBeLessThan=function(expected){
+287returnthis.actual<expected;
+288};
+289
+290jasmine.Matchers.prototype.toBeGreaterThan=function(expected){
+291returnthis.actual>expected;
+292};
+293
+294/**
+295 * Matcher that checks that the expected exception was thrown by the actual.
+296 *
+297 * @param {String} expected
+298 */
+299jasmine.Matchers.prototype.toThrow=function(expected){
+300varresult=false;
+301varexception;
+302if(typeofthis.actual!='function'){
+303thrownewError('Actual is not a function');
+304}
+305try{
+306this.actual();
+307}catch(e){
+308exception=e;
+309}
+310if(exception){
+311result=(expected===jasmine.undefined||this.env.equals_(exception.message||exception,expected.message||expected));
+312}
+313
+314varnot=this.isNot?"not ":"";
+315
+316this.message=function(){
+317if(exception&&(expected===jasmine.undefined||!this.env.equals_(exception.message||exception,expected.message||expected))){
+318return["Expected function "+not+"to throw",expected?expected.message||expected:" an exception",", but it threw",exception.message||exception].join(' ');
+319}else{
+320return"Expected function to throw an exception.";
+321}
+322};
+323
+324returnresult;
+325};
+326
+327jasmine.Matchers.Any=function(expectedClass){
+328this.expectedClass=expectedClass;
+329};
+330
+331jasmine.Matchers.Any.prototype.matches=function(other){
+332if(this.expectedClass==String){
+333returntypeofother=='string'||otherinstanceofString;
+334}
+335
+336if(this.expectedClass==Number){
+337returntypeofother=='number'||otherinstanceofNumber;
+338}
+339
+340if(this.expectedClass==Function){
+341returntypeofother=='function'||otherinstanceofFunction;
+342}
+343
+344if(this.expectedClass==Object){
+345returntypeofother=='object';
+346}
+347
+348returnotherinstanceofthis.expectedClass;
+349};
+350
+351jasmine.Matchers.Any.prototype.toString=function(){
+352return'<jasmine.any('+this.expectedClass+')>';
+353};
+354
+355
\ No newline at end of file
diff --git a/pages/jsdoc/symbols/src/src_MultiReporter.js.html b/pages/jsdoc/symbols/src/src_MultiReporter.js.html
new file mode 100644
index 0000000..2316cea
--- /dev/null
+++ b/pages/jsdoc/symbols/src/src_MultiReporter.js.html
@@ -0,0 +1,43 @@
+
\ No newline at end of file
diff --git a/pages/jsdoc/symbols/src/src_NestedResults.js.html b/pages/jsdoc/symbols/src/src_NestedResults.js.html
new file mode 100644
index 0000000..7a9e82a
--- /dev/null
+++ b/pages/jsdoc/symbols/src/src_NestedResults.js.html
@@ -0,0 +1,88 @@
+
1/**
+ 2 * Holds results for a set of Jasmine spec. Allows for the results array to hold another jasmine.NestedResults
+ 3 *
+ 4 * @constructor
+ 5 */
+ 6jasmine.NestedResults=function(){
+ 7/**
+ 8 * The total count of results
+ 9 */
+ 10this.totalCount=0;
+ 11/**
+ 12 * Number of passed results
+ 13 */
+ 14this.passedCount=0;
+ 15/**
+ 16 * Number of failed results
+ 17 */
+ 18this.failedCount=0;
+ 19/**
+ 20 * Was this suite/spec skipped?
+ 21 */
+ 22this.skipped=false;
+ 23/**
+ 24 * @ignore
+ 25 */
+ 26this.items_=[];
+ 27};
+ 28
+ 29/**
+ 30 * Roll up the result counts.
+ 31 *
+ 32 * @param result
+ 33 */
+ 34jasmine.NestedResults.prototype.rollupCounts=function(result){
+ 35this.totalCount+=result.totalCount;
+ 36this.passedCount+=result.passedCount;
+ 37this.failedCount+=result.failedCount;
+ 38};
+ 39
+ 40/**
+ 41 * Adds a log message.
+ 42 * @param values Array of message parts which will be concatenated later.
+ 43 */
+ 44jasmine.NestedResults.prototype.log=function(values){
+ 45this.items_.push(newjasmine.MessageResult(values));
+ 46};
+ 47
+ 48/**
+ 49 * Getter for the results: message & results.
+ 50 */
+ 51jasmine.NestedResults.prototype.getItems=function(){
+ 52returnthis.items_;
+ 53};
+ 54
+ 55/**
+ 56 * Adds a result, tracking counts (total, passed, & failed)
+ 57 * @param {jasmine.ExpectationResult|jasmine.NestedResults} result
+ 58 */
+ 59jasmine.NestedResults.prototype.addResult=function(result){
+ 60if(result.type!='log'){
+ 61if(result.items_){
+ 62this.rollupCounts(result);
+ 63}else{
+ 64this.totalCount++;
+ 65if(result.passed()){
+ 66this.passedCount++;
+ 67}else{
+ 68this.failedCount++;
+ 69}
+ 70}
+ 71}
+ 72this.items_.push(result);
+ 73};
+ 74
+ 75/**
+ 76 * @returns {Boolean} True if <b>everything</b> below passed
+ 77 */
+ 78jasmine.NestedResults.prototype.passed=function(){
+ 79returnthis.passedCount===this.totalCount;
+ 80};
+ 81
\ No newline at end of file
diff --git a/pages/jsdoc/symbols/src/src_PrettyPrinter.js.html b/pages/jsdoc/symbols/src/src_PrettyPrinter.js.html
new file mode 100644
index 0000000..9e638b4
--- /dev/null
+++ b/pages/jsdoc/symbols/src/src_PrettyPrinter.js.html
@@ -0,0 +1,130 @@
+
\ No newline at end of file
diff --git a/pages/jsdoc/symbols/src/src_Queue.js.html b/pages/jsdoc/symbols/src/src_Queue.js.html
new file mode 100644
index 0000000..3e798fc
--- /dev/null
+++ b/pages/jsdoc/symbols/src/src_Queue.js.html
@@ -0,0 +1,107 @@
+
\ No newline at end of file
diff --git a/pages/jsdoc/symbols/src/src_Reporter.js.html b/pages/jsdoc/symbols/src/src_Reporter.js.html
new file mode 100644
index 0000000..f5a65df
--- /dev/null
+++ b/pages/jsdoc/symbols/src/src_Reporter.js.html
@@ -0,0 +1,39 @@
+
\ No newline at end of file
diff --git a/pages/jsdoc/symbols/src/src_Runner.js.html b/pages/jsdoc/symbols/src/src_Runner.js.html
new file mode 100644
index 0000000..1bb191d
--- /dev/null
+++ b/pages/jsdoc/symbols/src/src_Runner.js.html
@@ -0,0 +1,84 @@
+
\ No newline at end of file
diff --git a/pages/jsdoc/symbols/src/src_Spec.js.html b/pages/jsdoc/symbols/src/src_Spec.js.html
new file mode 100644
index 0000000..8d7ef7f
--- /dev/null
+++ b/pages/jsdoc/symbols/src/src_Spec.js.html
@@ -0,0 +1,250 @@
+
1/**
+ 2 * Internal representation of a Jasmine specification, or test.
+ 3 *
+ 4 * @constructor
+ 5 * @param {jasmine.Env} env
+ 6 * @param {jasmine.Suite} suite
+ 7 * @param {String} description
+ 8 */
+ 9jasmine.Spec=function(env,suite,description){
+ 10if(!env){
+ 11thrownewError('jasmine.Env() required');
+ 12}
+ 13if(!suite){
+ 14thrownewError('jasmine.Suite() required');
+ 15}
+ 16varspec=this;
+ 17spec.id=env.nextSpecId?env.nextSpecId():null;
+ 18spec.env=env;
+ 19spec.suite=suite;
+ 20spec.description=description;
+ 21spec.queue=newjasmine.Queue(env);
+ 22
+ 23spec.afterCallbacks=[];
+ 24spec.spies_=[];
+ 25
+ 26spec.results_=newjasmine.NestedResults();
+ 27spec.results_.description=description;
+ 28spec.matchersClass=null;
+ 29};
+ 30
+ 31jasmine.Spec.prototype.getFullName=function(){
+ 32returnthis.suite.getFullName()+' '+this.description+'.';
+ 33};
+ 34
+ 35
+ 36jasmine.Spec.prototype.results=function(){
+ 37returnthis.results_;
+ 38};
+ 39
+ 40/**
+ 41 * All parameters are pretty-printed and concatenated together, then written to the spec's output.
+ 42 *
+ 43 * Be careful not to leave calls to <code>jasmine.log</code> in production code.
+ 44 */
+ 45jasmine.Spec.prototype.log=function(){
+ 46returnthis.results_.log(arguments);
+ 47};
+ 48
+ 49jasmine.Spec.prototype.runs=function(func){
+ 50varblock=newjasmine.Block(this.env,func,this);
+ 51this.addToQueue(block);
+ 52returnthis;
+ 53};
+ 54
+ 55jasmine.Spec.prototype.addToQueue=function(block){
+ 56if(this.queue.isRunning()){
+ 57this.queue.insertNext(block);
+ 58}else{
+ 59this.queue.add(block);
+ 60}
+ 61};
+ 62
+ 63/**
+ 64 * @param {jasmine.ExpectationResult} result
+ 65 */
+ 66jasmine.Spec.prototype.addMatcherResult=function(result){
+ 67this.results_.addResult(result);
+ 68};
+ 69
+ 70jasmine.Spec.prototype.expect=function(actual){
+ 71varpositive=new(this.getMatchersClass_())(this.env,actual,this);
+ 72positive.not=new(this.getMatchersClass_())(this.env,actual,this,true);
+ 73returnpositive;
+ 74};
+ 75
+ 76/**
+ 77 * Waits a fixed time period before moving to the next block.
+ 78 *
+ 79 * @deprecated Use waitsFor() instead
+ 80 * @param {Number} timeout milliseconds to wait
+ 81 */
+ 82jasmine.Spec.prototype.waits=function(timeout){
+ 83varwaitsFunc=newjasmine.WaitsBlock(this.env,timeout,this);
+ 84this.addToQueue(waitsFunc);
+ 85returnthis;
+ 86};
+ 87
+ 88/**
+ 89 * Waits for the latchFunction to return true before proceeding to the next block.
+ 90 *
+ 91 * @param {Function} latchFunction
+ 92 * @param {String} optional_timeoutMessage
+ 93 * @param {Number} optional_timeout
+ 94 */
+ 95jasmine.Spec.prototype.waitsFor=function(latchFunction,optional_timeoutMessage,optional_timeout){
+ 96varlatchFunction_=null;
+ 97varoptional_timeoutMessage_=null;
+ 98varoptional_timeout_=null;
+ 99
+100for(vari=0;i<arguments.length;i++){
+101vararg=arguments[i];
+102switch(typeofarg){
+103case'function':
+104latchFunction_=arg;
+105break;
+106case'string':
+107optional_timeoutMessage_=arg;
+108break;
+109case'number':
+110optional_timeout_=arg;
+111break;
+112}
+113}
+114
+115varwaitsForFunc=newjasmine.WaitsForBlock(this.env,optional_timeout_,latchFunction_,optional_timeoutMessage_,this);
+116this.addToQueue(waitsForFunc);
+117returnthis;
+118};
+119
+120jasmine.Spec.prototype.fail=function(e){
+121varexpectationResult=newjasmine.ExpectationResult({
+122passed:false,
+123message:e?jasmine.util.formatException(e):'Exception'
+124});
+125this.results_.addResult(expectationResult);
+126};
+127
+128jasmine.Spec.prototype.getMatchersClass_=function(){
+129returnthis.matchersClass||this.env.matchersClass;
+130};
+131
+132jasmine.Spec.prototype.addMatchers=function(matchersPrototype){
+133varparent=this.getMatchersClass_();
+134varnewMatchersClass=function(){
+135parent.apply(this,arguments);
+136};
+137jasmine.util.inherit(newMatchersClass,parent);
+138jasmine.Matchers.wrapInto_(matchersPrototype,newMatchersClass);
+139this.matchersClass=newMatchersClass;
+140};
+141
+142jasmine.Spec.prototype.finishCallback=function(){
+143this.env.reporter.reportSpecResults(this);
+144};
+145
+146jasmine.Spec.prototype.finish=function(onComplete){
+147this.removeAllSpies();
+148this.finishCallback();
+149if(onComplete){
+150onComplete();
+151}
+152};
+153
+154jasmine.Spec.prototype.after=function(doAfter){
+155if(this.queue.isRunning()){
+156this.queue.add(newjasmine.Block(this.env,doAfter,this));
+157}else{
+158this.afterCallbacks.unshift(doAfter);
+159}
+160};
+161
+162jasmine.Spec.prototype.execute=function(onComplete){
+163varspec=this;
+164if(!spec.env.specFilter(spec)){
+165spec.results_.skipped=true;
+166spec.finish(onComplete);
+167return;
+168}
+169
+170this.env.reporter.reportSpecStarting(this);
+171
+172spec.env.currentSpec=spec;
+173
+174spec.addBeforesAndAftersToQueue();
+175
+176spec.queue.start(function(){
+177spec.finish(onComplete);
+178});
+179};
+180
+181jasmine.Spec.prototype.addBeforesAndAftersToQueue=function(){
+182varrunner=this.env.currentRunner();
+183vari;
+184
+185for(varsuite=this.suite;suite;suite=suite.parentSuite){
+186for(i=0;i<suite.before_.length;i++){
+187this.queue.addBefore(newjasmine.Block(this.env,suite.before_[i],this));
+188}
+189}
+190for(i=0;i<runner.before_.length;i++){
+191this.queue.addBefore(newjasmine.Block(this.env,runner.before_[i],this));
+192}
+193for(i=0;i<this.afterCallbacks.length;i++){
+194this.queue.add(newjasmine.Block(this.env,this.afterCallbacks[i],this));
+195}
+196for(suite=this.suite;suite;suite=suite.parentSuite){
+197for(i=0;i<suite.after_.length;i++){
+198this.queue.add(newjasmine.Block(this.env,suite.after_[i],this));
+199}
+200}
+201for(i=0;i<runner.after_.length;i++){
+202this.queue.add(newjasmine.Block(this.env,runner.after_[i],this));
+203}
+204};
+205
+206jasmine.Spec.prototype.explodes=function(){
+207throw'explodes function should not have been called';
+208};
+209
+210jasmine.Spec.prototype.spyOn=function(obj,methodName,ignoreMethodDoesntExist){
+211if(obj==jasmine.undefined){
+212throw"spyOn could not find an object to spy upon for "+methodName+"()";
+213}
+214
+215if(!ignoreMethodDoesntExist&&obj[methodName]===jasmine.undefined){
+216throwmethodName+'() method does not exist';
+217}
+218
+219if(!ignoreMethodDoesntExist&&obj[methodName]&&obj[methodName].isSpy){
+220thrownewError(methodName+' has already been spied upon');
+221}
+222
+223varspyObj=jasmine.createSpy(methodName);
+224
+225this.spies_.push(spyObj);
+226spyObj.baseObj=obj;
+227spyObj.methodName=methodName;
+228spyObj.originalValue=obj[methodName];
+229
+230obj[methodName]=spyObj;
+231
+232returnspyObj;
+233};
+234
+235jasmine.Spec.prototype.removeAllSpies=function(){
+236for(vari=0;i<this.spies_.length;i++){
+237varspy=this.spies_[i];
+238spy.baseObj[spy.methodName]=spy.originalValue;
+239}
+240this.spies_=[];
+241};
+242
+243
\ No newline at end of file
diff --git a/pages/jsdoc/symbols/src/src_Suite.js.html b/pages/jsdoc/symbols/src/src_Suite.js.html
new file mode 100644
index 0000000..3ff28ae
--- /dev/null
+++ b/pages/jsdoc/symbols/src/src_Suite.js.html
@@ -0,0 +1,89 @@
+
\ No newline at end of file
diff --git a/pages/jsdoc/symbols/src/src_WaitsBlock.js.html b/pages/jsdoc/symbols/src/src_WaitsBlock.js.html
new file mode 100644
index 0000000..4a1f119
--- /dev/null
+++ b/pages/jsdoc/symbols/src/src_WaitsBlock.js.html
@@ -0,0 +1,21 @@
+
\ No newline at end of file
diff --git a/pages/jsdoc/symbols/src/src_WaitsForBlock.js.html b/pages/jsdoc/symbols/src/src_WaitsForBlock.js.html
new file mode 100644
index 0000000..5466ab4
--- /dev/null
+++ b/pages/jsdoc/symbols/src/src_WaitsForBlock.js.html
@@ -0,0 +1,59 @@
+
1/**
+ 2 * A block which waits for some condition to become true, with timeout.
+ 3 *
+ 4 * @constructor
+ 5 * @extends jasmine.Block
+ 6 * @param {jasmine.Env} env The Jasmine environment.
+ 7 * @param {Number} timeout The maximum time in milliseconds to wait for the condition to become true.
+ 8 * @param {Function} latchFunction A function which returns true when the desired condition has been met.
+ 9 * @param {String} message The message to display if the desired condition hasn't been met within the given time period.
+ 10 * @param {jasmine.Spec} spec The Jasmine spec.
+ 11 */
+ 12jasmine.WaitsForBlock=function(env,timeout,latchFunction,message,spec){
+ 13this.timeout=timeout||env.defaultTimeoutInterval;
+ 14this.latchFunction=latchFunction;
+ 15this.message=message;
+ 16this.totalTimeSpentWaitingForLatch=0;
+ 17jasmine.Block.call(this,env,null,spec);
+ 18};
+ 19jasmine.util.inherit(jasmine.WaitsForBlock,jasmine.Block);
+ 20
+ 21jasmine.WaitsForBlock.TIMEOUT_INCREMENT=10;
+ 22
+ 23jasmine.WaitsForBlock.prototype.execute=function(onComplete){
+ 24this.env.reporter.log('>> Jasmine waiting for '+(this.message||'something to happen'));
+ 25varlatchFunctionResult;
+ 26try{
+ 27latchFunctionResult=this.latchFunction.apply(this.spec);
+ 28}catch(e){
+ 29this.spec.fail(e);
+ 30onComplete();
+ 31return;
+ 32}
+ 33
+ 34if(latchFunctionResult){
+ 35onComplete();
+ 36}elseif(this.totalTimeSpentWaitingForLatch>=this.timeout){
+ 37varmessage='timed out after '+this.timeout+' msec waiting for '+(this.message||'something to happen');
+ 38this.spec.fail({
+ 39name:'timeout',
+ 40message:message
+ 41});
+ 42
+ 43this.abort=true;
+ 44onComplete();
+ 45}else{
+ 46this.totalTimeSpentWaitingForLatch+=jasmine.WaitsForBlock.TIMEOUT_INCREMENT;
+ 47varself=this;
+ 48this.env.setTimeout(function(){
+ 49self.execute(onComplete);
+ 50},jasmine.WaitsForBlock.TIMEOUT_INCREMENT);
+ 51}
+ 52};
\ No newline at end of file
diff --git a/pages/jsdoc/symbols/src/src_base.js.html b/pages/jsdoc/symbols/src/src_base.js.html
new file mode 100644
index 0000000..33add32
--- /dev/null
+++ b/pages/jsdoc/symbols/src/src_base.js.html
@@ -0,0 +1,597 @@
+
1/**
+ 2 * Top level namespace for Jasmine, a lightweight JavaScript BDD/spec/testing framework.
+ 3 *
+ 4 * @namespace
+ 5 */
+ 6varjasmine={};
+ 7
+ 8/**
+ 9 * @private
+ 10 */
+ 11jasmine.unimplementedMethod_=function(){
+ 12thrownewError("unimplemented method");
+ 13};
+ 14
+ 15/**
+ 16 * Use <code>jasmine.undefined</code> instead of <code>undefined</code>, since <code>undefined</code> is just
+ 17 * a plain old variable and may be redefined by somebody else.
+ 18 *
+ 19 * @private
+ 20 */
+ 21jasmine.undefined=jasmine.___undefined___;
+ 22
+ 23/**
+ 24 * 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.
+ 25 *
+ 26 */
+ 27jasmine.DEFAULT_UPDATE_INTERVAL=250;
+ 28
+ 29/**
+ 30 * Default timeout interval in milliseconds for waitsFor() blocks.
+ 31 */
+ 32jasmine.DEFAULT_TIMEOUT_INTERVAL=5000;
+ 33
+ 34jasmine.getGlobal=function(){
+ 35functiongetGlobal(){
+ 36returnthis;
+ 37}
+ 38
+ 39returngetGlobal();
+ 40};
+ 41
+ 42/**
+ 43 * Allows for bound functions to be compared. Internal use only.
+ 44 *
+ 45 * @ignore
+ 46 * @private
+ 47 * @param base {Object} bound 'this' for the function
+ 48 * @param name {Function} function to find
+ 49 */
+ 50jasmine.bindOriginal_=function(base,name){
+ 51varoriginal=base[name];
+ 52if(original.apply){
+ 53returnfunction(){
+ 54returnoriginal.apply(base,arguments);
+ 55};
+ 56}else{
+ 57// IE support
+ 58returnjasmine.getGlobal()[name];
+ 59}
+ 60};
+ 61
+ 62jasmine.setTimeout=jasmine.bindOriginal_(jasmine.getGlobal(),'setTimeout');
+ 63jasmine.clearTimeout=jasmine.bindOriginal_(jasmine.getGlobal(),'clearTimeout');
+ 64jasmine.setInterval=jasmine.bindOriginal_(jasmine.getGlobal(),'setInterval');
+ 65jasmine.clearInterval=jasmine.bindOriginal_(jasmine.getGlobal(),'clearInterval');
+ 66
+ 67jasmine.MessageResult=function(values){
+ 68this.type='log';
+ 69this.values=values;
+ 70this.trace=newError();// todo: test better
+ 71};
+ 72
+ 73jasmine.MessageResult.prototype.toString=function(){
+ 74vartext="";
+ 75for(vari=0;i<this.values.length;i++){
+ 76if(i>0)text+=" ";
+ 77if(jasmine.isString_(this.values[i])){
+ 78text+=this.values[i];
+ 79}else{
+ 80text+=jasmine.pp(this.values[i]);
+ 81}
+ 82}
+ 83returntext;
+ 84};
+ 85
+ 86jasmine.ExpectationResult=function(params){
+ 87this.type='expect';
+ 88this.matcherName=params.matcherName;
+ 89this.passed_=params.passed;
+ 90this.expected=params.expected;
+ 91this.actual=params.actual;
+ 92
+ 93this.message=this.passed_?'Passed.':params.message;
+ 94this.trace=this.passed_?'':newError(this.message);
+ 95};
+ 96
+ 97jasmine.ExpectationResult.prototype.toString=function(){
+ 98returnthis.message;
+ 99};
+100
+101jasmine.ExpectationResult.prototype.passed=function(){
+102returnthis.passed_;
+103};
+104
+105/**
+106 * Getter for the Jasmine environment. Ensures one gets created
+107 */
+108jasmine.getEnv=function(){
+109returnjasmine.currentEnv_=jasmine.currentEnv_||newjasmine.Env();
+110};
+111
+112/**
+113 * @ignore
+114 * @private
+115 * @param value
+116 * @returns {Boolean}
+117 */
+118jasmine.isArray_=function(value){
+119returnjasmine.isA_("Array",value);
+120};
+121
+122/**
+123 * @ignore
+124 * @private
+125 * @param value
+126 * @returns {Boolean}
+127 */
+128jasmine.isString_=function(value){
+129returnjasmine.isA_("String",value);
+130};
+131
+132/**
+133 * @ignore
+134 * @private
+135 * @param value
+136 * @returns {Boolean}
+137 */
+138jasmine.isNumber_=function(value){
+139returnjasmine.isA_("Number",value);
+140};
+141
+142/**
+143 * @ignore
+144 * @private
+145 * @param {String} typeName
+146 * @param value
+147 * @returns {Boolean}
+148 */
+149jasmine.isA_=function(typeName,value){
+150returnObject.prototype.toString.apply(value)==='[object '+typeName+']';
+151};
+152
+153/**
+154 * Pretty printer for expecations. Takes any object and turns it into a human-readable string.
+155 *
+156 * @param value {Object} an object to be outputted
+157 * @returns {String}
+158 */
+159jasmine.pp=function(value){
+160varstringPrettyPrinter=newjasmine.StringPrettyPrinter();
+161stringPrettyPrinter.format(value);
+162returnstringPrettyPrinter.string;
+163};
+164
+165/**
+166 * Returns true if the object is a DOM Node.
+167 *
+168 * @param {Object} obj object to check
+169 * @returns {Boolean}
+170 */
+171jasmine.isDomNode=function(obj){
+172returnobj['nodeType']>0;
+173};
+174
+175/**
+176 * Returns a matchable 'generic' object of the class type. For use in expecations of type when values don't matter.
+177 *
+178 * @example
+179 * // don't care about which function is passed in, as long as it's a function
+180 * expect(mySpy).toHaveBeenCalledWith(jasmine.any(Function));
+181 *
+182 * @param {Class} clazz
+183 * @returns matchable object of the type clazz
+184 */
+185jasmine.any=function(clazz){
+186returnnewjasmine.Matchers.Any(clazz);
+187};
+188
+189/**
+190 * Jasmine Spies are test doubles that can act as stubs, spies, fakes or when used in an expecation, mocks.
+191 *
+192 * Spies should be created in test setup, before expectations. They can then be checked, using the standard Jasmine
+193 * expectation syntax. Spies can be checked if they were called or not and what the calling params were.
+194 *
+195 * A Spy has the following fields: wasCalled, callCount, mostRecentCall, and argsForCall (see docs).
+196 *
+197 * Spies are torn down at the end of every spec.
+198 *
+199 * Note: Do <b>not</b> call new jasmine.Spy() directly - a spy must be created using spyOn, jasmine.createSpy or jasmine.createSpyObj.
+200 *
+201 * @example
+202 * // a stub
+203 * var myStub = jasmine.createSpy('myStub'); // can be used anywhere
+204 *
+205 * // spy example
+206 * var foo = {
+207 * not: function(bool) { return !bool; }
+208 * }
+209 *
+210 * // actual foo.not will not be called, execution stops
+211 * spyOn(foo, 'not');
+212
+213 // foo.not spied upon, execution will continue to implementation
+214 * spyOn(foo, 'not').andCallThrough();
+215 *
+216 * // fake example
+217 * var foo = {
+218 * not: function(bool) { return !bool; }
+219 * }
+220 *
+221 * // foo.not(val) will return val
+222 * spyOn(foo, 'not').andCallFake(function(value) {return value;});
+223 *
+224 * // mock example
+225 * foo.not(7 == 7);
+226 * expect(foo.not).toHaveBeenCalled();
+227 * expect(foo.not).toHaveBeenCalledWith(true);
+228 *
+229 * @constructor
+230 * @see spyOn, jasmine.createSpy, jasmine.createSpyObj
+231 * @param {String} name
+232 */
+233jasmine.Spy=function(name){
+234/**
+235 * The name of the spy, if provided.
+236 */
+237this.identity=name||'unknown';
+238/**
+239 * Is this Object a spy?
+240 */
+241this.isSpy=true;
+242/**
+243 * The actual function this spy stubs.
+244 */
+245this.plan=function(){
+246};
+247/**
+248 * Tracking of the most recent call to the spy.
+249 * @example
+250 * var mySpy = jasmine.createSpy('foo');
+251 * mySpy(1, 2);
+252 * mySpy.mostRecentCall.args = [1, 2];
+253 */
+254this.mostRecentCall={};
+255
+256/**
+257 * Holds arguments for each call to the spy, indexed by call count
+258 * @example
+259 * var mySpy = jasmine.createSpy('foo');
+260 * mySpy(1, 2);
+261 * mySpy(7, 8);
+262 * mySpy.mostRecentCall.args = [7, 8];
+263 * mySpy.argsForCall[0] = [1, 2];
+264 * mySpy.argsForCall[1] = [7, 8];
+265 */
+266this.argsForCall=[];
+267this.calls=[];
+268};
+269
+270/**
+271 * Tells a spy to call through to the actual implemenatation.
+272 *
+273 * @example
+274 * var foo = {
+275 * bar: function() { // do some stuff }
+276 * }
+277 *
+278 * // defining a spy on an existing property: foo.bar
+279 * spyOn(foo, 'bar').andCallThrough();
+280 */
+281jasmine.Spy.prototype.andCallThrough=function(){
+282this.plan=this.originalValue;
+283returnthis;
+284};
+285
+286/**
+287 * For setting the return value of a spy.
+288 *
+289 * @example
+290 * // defining a spy from scratch: foo() returns 'baz'
+291 * var foo = jasmine.createSpy('spy on foo').andReturn('baz');
+292 *
+293 * // defining a spy on an existing property: foo.bar() returns 'baz'
+294 * spyOn(foo, 'bar').andReturn('baz');
+295 *
+296 * @param {Object} value
+297 */
+298jasmine.Spy.prototype.andReturn=function(value){
+299this.plan=function(){
+300returnvalue;
+301};
+302returnthis;
+303};
+304
+305/**
+306 * For throwing an exception when a spy is called.
+307 *
+308 * @example
+309 * // defining a spy from scratch: foo() throws an exception w/ message 'ouch'
+310 * var foo = jasmine.createSpy('spy on foo').andThrow('baz');
+311 *
+312 * // defining a spy on an existing property: foo.bar() throws an exception w/ message 'ouch'
+313 * spyOn(foo, 'bar').andThrow('baz');
+314 *
+315 * @param {String} exceptionMsg
+316 */
+317jasmine.Spy.prototype.andThrow=function(exceptionMsg){
+318this.plan=function(){
+319throwexceptionMsg;
+320};
+321returnthis;
+322};
+323
+324/**
+325 * Calls an alternate implementation when a spy is called.
+326 *
+327 * @example
+328 * var baz = function() {
+329 * // do some stuff, return something
+330 * }
+331 * // defining a spy from scratch: foo() calls the function baz
+332 * var foo = jasmine.createSpy('spy on foo').andCall(baz);
+333 *
+334 * // defining a spy on an existing property: foo.bar() calls an anonymnous function
+335 * spyOn(foo, 'bar').andCall(function() { return 'baz';} );
+336 *
+337 * @param {Function} fakeFunc
+338 */
+339jasmine.Spy.prototype.andCallFake=function(fakeFunc){
+340this.plan=fakeFunc;
+341returnthis;
+342};
+343
+344/**
+345 * Resets all of a spy's the tracking variables so that it can be used again.
+346 *
+347 * @example
+348 * spyOn(foo, 'bar');
+349 *
+350 * foo.bar();
+351 *
+352 * expect(foo.bar.callCount).toEqual(1);
+353 *
+354 * foo.bar.reset();
+355 *
+356 * expect(foo.bar.callCount).toEqual(0);
+357 */
+358jasmine.Spy.prototype.reset=function(){
+359this.wasCalled=false;
+360this.callCount=0;
+361this.argsForCall=[];
+362this.calls=[];
+363this.mostRecentCall={};
+364};
+365
+366jasmine.createSpy=function(name){
+367
+368varspyObj=function(){
+369spyObj.wasCalled=true;
+370spyObj.callCount++;
+371varargs=jasmine.util.argsToArray(arguments);
+372spyObj.mostRecentCall.object=this;
+373spyObj.mostRecentCall.args=args;
+374spyObj.argsForCall.push(args);
+375spyObj.calls.push({object:this,args:args});
+376returnspyObj.plan.apply(this,arguments);
+377};
+378
+379varspy=newjasmine.Spy(name);
+380
+381for(varpropinspy){
+382spyObj[prop]=spy[prop];
+383}
+384
+385spyObj.reset();
+386
+387returnspyObj;
+388};
+389
+390/**
+391 * Determines whether an object is a spy.
+392 *
+393 * @param {jasmine.Spy|Object} putativeSpy
+394 * @returns {Boolean}
+395 */
+396jasmine.isSpy=function(putativeSpy){
+397returnputativeSpy&&putativeSpy.isSpy;
+398};
+399
+400/**
+401 * Creates a more complicated spy: an Object that has every property a function that is a spy. Used for stubbing something
+402 * large in one call.
+403 *
+404 * @param {String} baseName name of spy class
+405 * @param {Array} methodNames array of names of methods to make spies
+406 */
+407jasmine.createSpyObj=function(baseName,methodNames){
+408if(!jasmine.isArray_(methodNames)||methodNames.length==0){
+409thrownewError('createSpyObj requires a non-empty array of method names to create spies for');
+410}
+411varobj={};
+412for(vari=0;i<methodNames.length;i++){
+413obj[methodNames[i]]=jasmine.createSpy(baseName+'.'+methodNames[i]);
+414}
+415returnobj;
+416};
+417
+418/**
+419 * All parameters are pretty-printed and concatenated together, then written to the current spec's output.
+420 *
+421 * Be careful not to leave calls to <code>jasmine.log</code> in production code.
+422 */
+423jasmine.log=function(){
+424varspec=jasmine.getEnv().currentSpec;
+425spec.log.apply(spec,arguments);
+426};
+427
+428/**
+429 * Function that installs a spy on an existing object's method name. Used within a Spec to create a spy.
+430 *
+431 * @example
+432 * // spy example
+433 * var foo = {
+434 * not: function(bool) { return !bool; }
+435 * }
+436 * spyOn(foo, 'not'); // actual foo.not will not be called, execution stops
+437 *
+438 * @see jasmine.createSpy
+439 * @param obj
+440 * @param methodName
+441 * @returns a Jasmine spy that can be chained with all spy methods
+442 */
+443varspyOn=function(obj,methodName){
+444returnjasmine.getEnv().currentSpec.spyOn(obj,methodName);
+445};
+446
+447/**
+448 * Creates a Jasmine spec that will be added to the current suite.
+449 *
+450 * // TODO: pending tests
+451 *
+452 * @example
+453 * it('should be true', function() {
+454 * expect(true).toEqual(true);
+455 * });
+456 *
+457 * @param {String} desc description of this specification
+458 * @param {Function} func defines the preconditions and expectations of the spec
+459 */
+460varit=function(desc,func){
+461returnjasmine.getEnv().it(desc,func);
+462};
+463
+464/**
+465 * Creates a <em>disabled</em> Jasmine spec.
+466 *
+467 * A convenience method that allows existing specs to be disabled temporarily during development.
+468 *
+469 * @param {String} desc description of this specification
+470 * @param {Function} func defines the preconditions and expectations of the spec
+471 */
+472varxit=function(desc,func){
+473returnjasmine.getEnv().xit(desc,func);
+474};
+475
+476/**
+477 * Starts a chain for a Jasmine expectation.
+478 *
+479 * It is passed an Object that is the actual value and should chain to one of the many
+480 * jasmine.Matchers functions.
+481 *
+482 * @param {Object} actual Actual value to test against and expected value
+483 */
+484varexpect=function(actual){
+485returnjasmine.getEnv().currentSpec.expect(actual);
+486};
+487
+488/**
+489 * Defines part of a jasmine spec. Used in cominbination with waits or waitsFor in asynchrnous specs.
+490 *
+491 * @param {Function} func Function that defines part of a jasmine spec.
+492 */
+493varruns=function(func){
+494jasmine.getEnv().currentSpec.runs(func);
+495};
+496
+497/**
+498 * Waits a fixed time period before moving to the next block.
+499 *
+500 * @deprecated Use waitsFor() instead
+501 * @param {Number} timeout milliseconds to wait
+502 */
+503varwaits=function(timeout){
+504jasmine.getEnv().currentSpec.waits(timeout);
+505};
+506
+507/**
+508 * Waits for the latchFunction to return true before proceeding to the next block.
+509 *
+510 * @param {Function} latchFunction
+511 * @param {String} optional_timeoutMessage
+512 * @param {Number} optional_timeout
+513 */
+514varwaitsFor=function(latchFunction,optional_timeoutMessage,optional_timeout){
+515jasmine.getEnv().currentSpec.waitsFor.apply(jasmine.getEnv().currentSpec,arguments);
+516};
+517
+518/**
+519 * A function that is called before each spec in a suite.
+520 *
+521 * Used for spec setup, including validating assumptions.
+522 *
+523 * @param {Function} beforeEachFunction
+524 */
+525varbeforeEach=function(beforeEachFunction){
+526jasmine.getEnv().beforeEach(beforeEachFunction);
+527};
+528
+529/**
+530 * A function that is called after each spec in a suite.
+531 *
+532 * Used for restoring any state that is hijacked during spec execution.
+533 *
+534 * @param {Function} afterEachFunction
+535 */
+536varafterEach=function(afterEachFunction){
+537jasmine.getEnv().afterEach(afterEachFunction);
+538};
+539
+540/**
+541 * Defines a suite of specifications.
+542 *
+543 * Stores the description and all defined specs in the Jasmine environment as one suite of specs. Variables declared
+544 * are accessible by calls to beforeEach, it, and afterEach. Describe blocks can be nested, allowing for specialization
+545 * of setup in some tests.
+546 *
+547 * @example
+548 * // TODO: a simple suite
+549 *
+550 * // TODO: a simple suite with a nested describe block
+551 *
+552 * @param {String} description A string, usually the class under test.
+553 * @param {Function} specDefinitions function that defines several specs.
+554 */
+555vardescribe=function(description,specDefinitions){
+556returnjasmine.getEnv().describe(description,specDefinitions);
+557};
+558
+559/**
+560 * Disables a suite of specifications. Used to disable some suites in a file, or files, temporarily during development.
+561 *
+562 * @param {String} description A string, usually the class under test.
+563 * @param {Function} specDefinitions function that defines several specs.
+564 */
+565varxdescribe=function(description,specDefinitions){
+566returnjasmine.getEnv().xdescribe(description,specDefinitions);
+567};
+568
+569
+570// Provide the XMLHttpRequest class for IE 5.x-6.x:
+571jasmine.XmlHttpRequest=(typeofXMLHttpRequest=="undefined")?function(){
+572try{
+573returnnewActiveXObject("Msxml2.XMLHTTP.6.0");
+574}catch(e){
+575}
+576try{
+577returnnewActiveXObject("Msxml2.XMLHTTP.3.0");
+578}catch(e){
+579}
+580try{
+581returnnewActiveXObject("Msxml2.XMLHTTP");
+582}catch(e){
+583}
+584try{
+585returnnewActiveXObject("Microsoft.XMLHTTP");
+586}catch(e){
+587}
+588thrownewError("This browser does not support XMLHttpRequest.");
+589}:XMLHttpRequest;
+590
\ No newline at end of file
diff --git a/pages/jsdoc/symbols/src/src_html_TrivialReporter.js.html b/pages/jsdoc/symbols/src/src_html_TrivialReporter.js.html
new file mode 100644
index 0000000..1f8915a
--- /dev/null
+++ b/pages/jsdoc/symbols/src/src_html_TrivialReporter.js.html
@@ -0,0 +1,196 @@
+
\ No newline at end of file
diff --git a/pages/jsdoc/symbols/src/src_mock-timeout.js.html b/pages/jsdoc/symbols/src/src_mock-timeout.js.html
new file mode 100644
index 0000000..93f9afc
--- /dev/null
+++ b/pages/jsdoc/symbols/src/src_mock-timeout.js.html
@@ -0,0 +1,191 @@
+
\ No newline at end of file
diff --git a/pages/jsdoc/symbols/src/src_util.js.html b/pages/jsdoc/symbols/src/src_util.js.html
new file mode 100644
index 0000000..31f3e27
--- /dev/null
+++ b/pages/jsdoc/symbols/src/src_util.js.html
@@ -0,0 +1,75 @@
+
+ These files are for the standalone release, meant for inclusion on a static HTML page and manual management of files.
+
+
+ For a using Jasmine with Ruby on Rails, other Ruby frameworks, within continuous integration environments, or to gain more dynamic source and test file loading, see
+ Using the Jasmine Gem
+ .
+
+
+
+
+
Version
+
Size
+
Date
+
SHA1
+
+
+
+
+ Powered by
+
+
+
+
diff --git a/pages/pages_source/out/favicon.ico b/pages/pages_source/out/favicon.ico
new file mode 100644
index 0000000..e69de29
diff --git a/pages/pages_source/out/images/jasmine_logo.png b/pages/pages_source/out/images/jasmine_logo.png
new file mode 100644
index 0000000..9ffc5a0
Binary files /dev/null and b/pages/pages_source/out/images/jasmine_logo.png differ
diff --git a/pages/pages_source/out/images/pivotal_logo.gif b/pages/pages_source/out/images/pivotal_logo.gif
new file mode 100644
index 0000000..9306043
Binary files /dev/null and b/pages/pages_source/out/images/pivotal_logo.gif differ
diff --git a/pages/pages_source/out/index.html b/pages/pages_source/out/index.html
new file mode 100644
index 0000000..e5563f9
--- /dev/null
+++ b/pages/pages_source/out/index.html
@@ -0,0 +1,79 @@
+
+
+
+
+ Jasmine: BDD for your JavaScript
+
+
+
+
+
+
+
+
+
+
BDD for JavaScript
+
+
+
+ Jasmine is a behavior-driven development framework for testing your JavaScript code. It does not depend on any other
+ JavaScript frameworks. It does not require a DOM. And it has a clean, obvious syntax so that you can easily write tests.
+
+ Jasmine can be run anywhere you can execute JavaScript: a static web page, your continuous integration environment,
+ or server-side environments like
+ Node.js
+ .
+
+ 
+ 
+ 
+