coherent 0.6.9 → 0.6.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,2421 @@
1
+ /**
2
+ * Top level namespace for Jasmine, a lightweight JavaScript BDD/spec/testing framework.
3
+ *
4
+ * @namespace
5
+ */
6
+ var jasmine = {};
7
+
8
+ /**
9
+ * @private
10
+ */
11
+ jasmine.unimplementedMethod_ = function() {
12
+ throw new Error("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
+ */
21
+ jasmine.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
+ */
27
+ jasmine.DEFAULT_UPDATE_INTERVAL = 250;
28
+
29
+ /**
30
+ * Default timeout interval in milliseconds for waitsFor() blocks.
31
+ */
32
+ jasmine.DEFAULT_TIMEOUT_INTERVAL = 5000;
33
+
34
+ jasmine.getGlobal = function() {
35
+ function getGlobal() {
36
+ return this;
37
+ }
38
+
39
+ return getGlobal();
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
+ */
50
+ jasmine.bindOriginal_ = function(base, name) {
51
+ var original = base[name];
52
+ if (original.apply) {
53
+ return function() {
54
+ return original.apply(base, arguments);
55
+ };
56
+ } else {
57
+ // IE support
58
+ return jasmine.getGlobal()[name];
59
+ }
60
+ };
61
+
62
+ jasmine.setTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'setTimeout');
63
+ jasmine.clearTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearTimeout');
64
+ jasmine.setInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'setInterval');
65
+ jasmine.clearInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearInterval');
66
+
67
+ jasmine.MessageResult = function(values) {
68
+ this.type = 'log';
69
+ this.values = values;
70
+ this.trace = new Error(); // todo: test better
71
+ };
72
+
73
+ jasmine.MessageResult.prototype.toString = function() {
74
+ var text = "";
75
+ for(var i = 0; i < this.values.length; i++) {
76
+ if (i > 0) text += " ";
77
+ if (jasmine.isString_(this.values[i])) {
78
+ text += this.values[i];
79
+ } else {
80
+ text += jasmine.pp(this.values[i]);
81
+ }
82
+ }
83
+ return text;
84
+ };
85
+
86
+ jasmine.ExpectationResult = function(params) {
87
+ this.type = 'expect';
88
+ this.matcherName = params.matcherName;
89
+ this.passed_ = params.passed;
90
+ this.expected = params.expected;
91
+ this.actual = params.actual;
92
+
93
+ this.message = this.passed_ ? 'Passed.' : params.message;
94
+ this.trace = this.passed_ ? '' : new Error(this.message);
95
+ };
96
+
97
+ jasmine.ExpectationResult.prototype.toString = function () {
98
+ return this.message;
99
+ };
100
+
101
+ jasmine.ExpectationResult.prototype.passed = function () {
102
+ return this.passed_;
103
+ };
104
+
105
+ /**
106
+ * Getter for the Jasmine environment. Ensures one gets created
107
+ */
108
+ jasmine.getEnv = function() {
109
+ return jasmine.currentEnv_ = jasmine.currentEnv_ || new jasmine.Env();
110
+ };
111
+
112
+ /**
113
+ * @ignore
114
+ * @private
115
+ * @param value
116
+ * @returns {Boolean}
117
+ */
118
+ jasmine.isArray_ = function(value) {
119
+ return jasmine.isA_("Array", value);
120
+ };
121
+
122
+ /**
123
+ * @ignore
124
+ * @private
125
+ * @param value
126
+ * @returns {Boolean}
127
+ */
128
+ jasmine.isString_ = function(value) {
129
+ return jasmine.isA_("String", value);
130
+ };
131
+
132
+ /**
133
+ * @ignore
134
+ * @private
135
+ * @param value
136
+ * @returns {Boolean}
137
+ */
138
+ jasmine.isNumber_ = function(value) {
139
+ return jasmine.isA_("Number", value);
140
+ };
141
+
142
+ /**
143
+ * @ignore
144
+ * @private
145
+ * @param {String} typeName
146
+ * @param value
147
+ * @returns {Boolean}
148
+ */
149
+ jasmine.isA_ = function(typeName, value) {
150
+ return Object.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
+ */
159
+ jasmine.pp = function(value) {
160
+ var stringPrettyPrinter = new jasmine.StringPrettyPrinter();
161
+ stringPrettyPrinter.format(value);
162
+ return stringPrettyPrinter.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
+ */
171
+ jasmine.isDomNode = function(obj) {
172
+ return obj['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
+ */
185
+ jasmine.any = function(clazz) {
186
+ return new jasmine.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
+ */
233
+ jasmine.Spy = function(name) {
234
+ /**
235
+ * The name of the spy, if provided.
236
+ */
237
+ this.identity = name || 'unknown';
238
+ /**
239
+ * Is this Object a spy?
240
+ */
241
+ this.isSpy = true;
242
+ /**
243
+ * The actual function this spy stubs.
244
+ */
245
+ this.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
+ */
254
+ this.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
+ */
266
+ this.argsForCall = [];
267
+ this.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
+ */
281
+ jasmine.Spy.prototype.andCallThrough = function() {
282
+ this.plan = this.originalValue;
283
+ return this;
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
+ */
298
+ jasmine.Spy.prototype.andReturn = function(value) {
299
+ this.plan = function() {
300
+ return value;
301
+ };
302
+ return this;
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
+ */
317
+ jasmine.Spy.prototype.andThrow = function(exceptionMsg) {
318
+ this.plan = function() {
319
+ throw exceptionMsg;
320
+ };
321
+ return this;
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
+ */
339
+ jasmine.Spy.prototype.andCallFake = function(fakeFunc) {
340
+ this.plan = fakeFunc;
341
+ return this;
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
+ */
358
+ jasmine.Spy.prototype.reset = function() {
359
+ this.wasCalled = false;
360
+ this.callCount = 0;
361
+ this.argsForCall = [];
362
+ this.calls = [];
363
+ this.mostRecentCall = {};
364
+ };
365
+
366
+ jasmine.createSpy = function(name) {
367
+
368
+ var spyObj = function() {
369
+ spyObj.wasCalled = true;
370
+ spyObj.callCount++;
371
+ var args = jasmine.util.argsToArray(arguments);
372
+ spyObj.mostRecentCall.object = this;
373
+ spyObj.mostRecentCall.args = args;
374
+ spyObj.argsForCall.push(args);
375
+ spyObj.calls.push({object: this, args: args});
376
+ return spyObj.plan.apply(this, arguments);
377
+ };
378
+
379
+ var spy = new jasmine.Spy(name);
380
+
381
+ for (var prop in spy) {
382
+ spyObj[prop] = spy[prop];
383
+ }
384
+
385
+ spyObj.reset();
386
+
387
+ return spyObj;
388
+ };
389
+
390
+ /**
391
+ * Determines whether an object is a spy.
392
+ *
393
+ * @param {jasmine.Spy|Object} putativeSpy
394
+ * @returns {Boolean}
395
+ */
396
+ jasmine.isSpy = function(putativeSpy) {
397
+ return putativeSpy && 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
+ */
407
+ jasmine.createSpyObj = function(baseName, methodNames) {
408
+ if (!jasmine.isArray_(methodNames) || methodNames.length == 0) {
409
+ throw new Error('createSpyObj requires a non-empty array of method names to create spies for');
410
+ }
411
+ var obj = {};
412
+ for (var i = 0; i < methodNames.length; i++) {
413
+ obj[methodNames[i]] = jasmine.createSpy(baseName + '.' + methodNames[i]);
414
+ }
415
+ return obj;
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
+ */
423
+ jasmine.log = function() {
424
+ var spec = jasmine.getEnv().currentSpec;
425
+ spec.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
+ */
443
+ var spyOn = function(obj, methodName) {
444
+ return jasmine.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
+ */
460
+ var it = function(desc, func) {
461
+ return jasmine.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
+ */
472
+ var xit = function(desc, func) {
473
+ return jasmine.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
+ */
484
+ var expect = function(actual) {
485
+ return jasmine.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
+ */
493
+ var runs = function(func) {
494
+ jasmine.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
+ */
503
+ var waits = function(timeout) {
504
+ jasmine.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
+ */
514
+ var waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) {
515
+ jasmine.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
+ */
525
+ var beforeEach = function(beforeEachFunction) {
526
+ jasmine.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
+ */
536
+ var afterEach = function(afterEachFunction) {
537
+ jasmine.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
+ */
555
+ var describe = function(description, specDefinitions) {
556
+ return jasmine.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
+ */
565
+ var xdescribe = function(description, specDefinitions) {
566
+ return jasmine.getEnv().xdescribe(description, specDefinitions);
567
+ };
568
+
569
+
570
+ // Provide the XMLHttpRequest class for IE 5.x-6.x:
571
+ jasmine.XmlHttpRequest = (typeof XMLHttpRequest == "undefined") ? function() {
572
+ try {
573
+ return new ActiveXObject("Msxml2.XMLHTTP.6.0");
574
+ } catch(e) {
575
+ }
576
+ try {
577
+ return new ActiveXObject("Msxml2.XMLHTTP.3.0");
578
+ } catch(e) {
579
+ }
580
+ try {
581
+ return new ActiveXObject("Msxml2.XMLHTTP");
582
+ } catch(e) {
583
+ }
584
+ try {
585
+ return new ActiveXObject("Microsoft.XMLHTTP");
586
+ } catch(e) {
587
+ }
588
+ throw new Error("This browser does not support XMLHttpRequest.");
589
+ } : XMLHttpRequest;
590
+ /**
591
+ * @namespace
592
+ */
593
+ jasmine.util = {};
594
+
595
+ /**
596
+ * Declare that a child class inherit it's prototype from the parent class.
597
+ *
598
+ * @private
599
+ * @param {Function} childClass
600
+ * @param {Function} parentClass
601
+ */
602
+ jasmine.util.inherit = function(childClass, parentClass) {
603
+ /**
604
+ * @private
605
+ */
606
+ var subclass = function() {
607
+ };
608
+ subclass.prototype = parentClass.prototype;
609
+ childClass.prototype = new subclass;
610
+ };
611
+
612
+ jasmine.util.formatException = function(e) {
613
+ var lineNumber;
614
+ if (e.line) {
615
+ lineNumber = e.line;
616
+ }
617
+ else if (e.lineNumber) {
618
+ lineNumber = e.lineNumber;
619
+ }
620
+
621
+ var file;
622
+
623
+ if (e.sourceURL) {
624
+ file = e.sourceURL;
625
+ }
626
+ else if (e.fileName) {
627
+ file = e.fileName;
628
+ }
629
+
630
+ var message = (e.name && e.message) ? (e.name + ': ' + e.message) : e.toString();
631
+
632
+ if (file && lineNumber) {
633
+ message += ' in ' + file + ' (line ' + lineNumber + ')';
634
+ }
635
+
636
+ return message;
637
+ };
638
+
639
+ jasmine.util.htmlEscape = function(str) {
640
+ if (!str) return str;
641
+ return str.replace(/&/g, '&amp;')
642
+ .replace(/</g, '&lt;')
643
+ .replace(/>/g, '&gt;');
644
+ };
645
+
646
+ jasmine.util.argsToArray = function(args) {
647
+ var arrayOfArgs = [];
648
+ for (var i = 0; i < args.length; i++) arrayOfArgs.push(args[i]);
649
+ return arrayOfArgs;
650
+ };
651
+
652
+ jasmine.util.extend = function(destination, source) {
653
+ for (var property in source) destination[property] = source[property];
654
+ return destination;
655
+ };
656
+
657
+ /**
658
+ * Environment for Jasmine
659
+ *
660
+ * @constructor
661
+ */
662
+ jasmine.Env = function() {
663
+ this.currentSpec = null;
664
+ this.currentSuite = null;
665
+ this.currentRunner_ = new jasmine.Runner(this);
666
+
667
+ this.reporter = new jasmine.MultiReporter();
668
+
669
+ this.updateInterval = jasmine.DEFAULT_UPDATE_INTERVAL;
670
+ this.defaultTimeoutInterval = jasmine.DEFAULT_TIMEOUT_INTERVAL;
671
+ this.lastUpdate = 0;
672
+ this.specFilter = function() {
673
+ return true;
674
+ };
675
+
676
+ this.nextSpecId_ = 0;
677
+ this.nextSuiteId_ = 0;
678
+ this.equalityTesters_ = [];
679
+
680
+ // wrap matchers
681
+ this.matchersClass = function() {
682
+ jasmine.Matchers.apply(this, arguments);
683
+ };
684
+ jasmine.util.inherit(this.matchersClass, jasmine.Matchers);
685
+
686
+ jasmine.Matchers.wrapInto_(jasmine.Matchers.prototype, this.matchersClass);
687
+ };
688
+
689
+
690
+ jasmine.Env.prototype.setTimeout = jasmine.setTimeout;
691
+ jasmine.Env.prototype.clearTimeout = jasmine.clearTimeout;
692
+ jasmine.Env.prototype.setInterval = jasmine.setInterval;
693
+ jasmine.Env.prototype.clearInterval = jasmine.clearInterval;
694
+
695
+ /**
696
+ * @returns an object containing jasmine version build info, if set.
697
+ */
698
+ jasmine.Env.prototype.version = function () {
699
+ if (jasmine.version_) {
700
+ return jasmine.version_;
701
+ } else {
702
+ throw new Error('Version not set');
703
+ }
704
+ };
705
+
706
+ /**
707
+ * @returns string containing jasmine version build info, if set.
708
+ */
709
+ jasmine.Env.prototype.versionString = function() {
710
+ if (jasmine.version_) {
711
+ var version = this.version();
712
+ return version.major + "." + version.minor + "." + version.build + " revision " + version.revision;
713
+ } else {
714
+ return "version unknown";
715
+ }
716
+ };
717
+
718
+ /**
719
+ * @returns a sequential integer starting at 0
720
+ */
721
+ jasmine.Env.prototype.nextSpecId = function () {
722
+ return this.nextSpecId_++;
723
+ };
724
+
725
+ /**
726
+ * @returns a sequential integer starting at 0
727
+ */
728
+ jasmine.Env.prototype.nextSuiteId = function () {
729
+ return this.nextSuiteId_++;
730
+ };
731
+
732
+ /**
733
+ * Register a reporter to receive status updates from Jasmine.
734
+ * @param {jasmine.Reporter} reporter An object which will receive status updates.
735
+ */
736
+ jasmine.Env.prototype.addReporter = function(reporter) {
737
+ this.reporter.addReporter(reporter);
738
+ };
739
+
740
+ jasmine.Env.prototype.execute = function() {
741
+ this.currentRunner_.execute();
742
+ };
743
+
744
+ jasmine.Env.prototype.describe = function(description, specDefinitions) {
745
+ var suite = new jasmine.Suite(this, description, specDefinitions, this.currentSuite);
746
+
747
+ var parentSuite = this.currentSuite;
748
+ if (parentSuite) {
749
+ parentSuite.add(suite);
750
+ } else {
751
+ this.currentRunner_.add(suite);
752
+ }
753
+
754
+ this.currentSuite = suite;
755
+
756
+ var declarationError = null;
757
+ try {
758
+ specDefinitions.call(suite);
759
+ } catch(e) {
760
+ declarationError = e;
761
+ }
762
+
763
+ this.currentSuite = parentSuite;
764
+
765
+ if (declarationError) {
766
+ this.it("encountered a declaration exception", function() {
767
+ throw declarationError;
768
+ });
769
+ }
770
+
771
+ return suite;
772
+ };
773
+
774
+ jasmine.Env.prototype.beforeEach = function(beforeEachFunction) {
775
+ if (this.currentSuite) {
776
+ this.currentSuite.beforeEach(beforeEachFunction);
777
+ } else {
778
+ this.currentRunner_.beforeEach(beforeEachFunction);
779
+ }
780
+ };
781
+
782
+ jasmine.Env.prototype.currentRunner = function () {
783
+ return this.currentRunner_;
784
+ };
785
+
786
+ jasmine.Env.prototype.afterEach = function(afterEachFunction) {
787
+ if (this.currentSuite) {
788
+ this.currentSuite.afterEach(afterEachFunction);
789
+ } else {
790
+ this.currentRunner_.afterEach(afterEachFunction);
791
+ }
792
+
793
+ };
794
+
795
+ jasmine.Env.prototype.xdescribe = function(desc, specDefinitions) {
796
+ return {
797
+ execute: function() {
798
+ }
799
+ };
800
+ };
801
+
802
+ jasmine.Env.prototype.it = function(description, func) {
803
+ var spec = new jasmine.Spec(this, this.currentSuite, description);
804
+ this.currentSuite.add(spec);
805
+ this.currentSpec = spec;
806
+
807
+ if (func) {
808
+ spec.runs(func);
809
+ }
810
+
811
+ return spec;
812
+ };
813
+
814
+ jasmine.Env.prototype.xit = function(desc, func) {
815
+ return {
816
+ id: this.nextSpecId(),
817
+ runs: function() {
818
+ }
819
+ };
820
+ };
821
+
822
+ jasmine.Env.prototype.compareObjects_ = function(a, b, mismatchKeys, mismatchValues) {
823
+ if (a.__Jasmine_been_here_before__ === b && b.__Jasmine_been_here_before__ === a) {
824
+ return true;
825
+ }
826
+
827
+ a.__Jasmine_been_here_before__ = b;
828
+ b.__Jasmine_been_here_before__ = a;
829
+
830
+ var hasKey = function(obj, keyName) {
831
+ return obj != null && obj[keyName] !== jasmine.undefined;
832
+ };
833
+
834
+ for (var property in b) {
835
+ if (!hasKey(a, property) && hasKey(b, property)) {
836
+ mismatchKeys.push("expected has key '" + property + "', but missing from actual.");
837
+ }
838
+ }
839
+ for (property in a) {
840
+ if (!hasKey(b, property) && hasKey(a, property)) {
841
+ mismatchKeys.push("expected missing key '" + property + "', but present in actual.");
842
+ }
843
+ }
844
+ for (property in b) {
845
+ if (property == '__Jasmine_been_here_before__') continue;
846
+ if (!this.equals_(a[property], b[property], mismatchKeys, mismatchValues)) {
847
+ mismatchValues.push("'" + property + "' was '" + (b[property] ? jasmine.util.htmlEscape(b[property].toString()) : b[property]) + "' in expected, but was '" + (a[property] ? jasmine.util.htmlEscape(a[property].toString()) : a[property]) + "' in actual.");
848
+ }
849
+ }
850
+
851
+ if (jasmine.isArray_(a) && jasmine.isArray_(b) && a.length != b.length) {
852
+ mismatchValues.push("arrays were not the same length");
853
+ }
854
+
855
+ delete a.__Jasmine_been_here_before__;
856
+ delete b.__Jasmine_been_here_before__;
857
+ return (mismatchKeys.length == 0 && mismatchValues.length == 0);
858
+ };
859
+
860
+ jasmine.Env.prototype.equals_ = function(a, b, mismatchKeys, mismatchValues) {
861
+ mismatchKeys = mismatchKeys || [];
862
+ mismatchValues = mismatchValues || [];
863
+
864
+ for (var i = 0; i < this.equalityTesters_.length; i++) {
865
+ var equalityTester = this.equalityTesters_[i];
866
+ var result = equalityTester(a, b, this, mismatchKeys, mismatchValues);
867
+ if (result !== jasmine.undefined) return result;
868
+ }
869
+
870
+ if (a === b) return true;
871
+
872
+ if (a === jasmine.undefined || a === null || b === jasmine.undefined || b === null) {
873
+ return (a == jasmine.undefined && b == jasmine.undefined);
874
+ }
875
+
876
+ if (jasmine.isDomNode(a) && jasmine.isDomNode(b)) {
877
+ return a === b;
878
+ }
879
+
880
+ if (a instanceof Date && b instanceof Date) {
881
+ return a.getTime() == b.getTime();
882
+ }
883
+
884
+ if (a instanceof jasmine.Matchers.Any) {
885
+ return a.matches(b);
886
+ }
887
+
888
+ if (b instanceof jasmine.Matchers.Any) {
889
+ return b.matches(a);
890
+ }
891
+
892
+ if (jasmine.isString_(a) && jasmine.isString_(b)) {
893
+ return (a == b);
894
+ }
895
+
896
+ if (jasmine.isNumber_(a) && jasmine.isNumber_(b)) {
897
+ return (a == b);
898
+ }
899
+
900
+ if (typeof a === "object" && typeof b === "object") {
901
+ return this.compareObjects_(a, b, mismatchKeys, mismatchValues);
902
+ }
903
+
904
+ //Straight check
905
+ return (a === b);
906
+ };
907
+
908
+ jasmine.Env.prototype.contains_ = function(haystack, needle) {
909
+ if (jasmine.isArray_(haystack)) {
910
+ for (var i = 0; i < haystack.length; i++) {
911
+ if (this.equals_(haystack[i], needle)) return true;
912
+ }
913
+ return false;
914
+ }
915
+ return haystack.indexOf(needle) >= 0;
916
+ };
917
+
918
+ jasmine.Env.prototype.addEqualityTester = function(equalityTester) {
919
+ this.equalityTesters_.push(equalityTester);
920
+ };
921
+ /** No-op base class for Jasmine reporters.
922
+ *
923
+ * @constructor
924
+ */
925
+ jasmine.Reporter = function() {
926
+ };
927
+
928
+ //noinspection JSUnusedLocalSymbols
929
+ jasmine.Reporter.prototype.reportRunnerStarting = function(runner) {
930
+ };
931
+
932
+ //noinspection JSUnusedLocalSymbols
933
+ jasmine.Reporter.prototype.reportRunnerResults = function(runner) {
934
+ };
935
+
936
+ //noinspection JSUnusedLocalSymbols
937
+ jasmine.Reporter.prototype.reportSuiteResults = function(suite) {
938
+ };
939
+
940
+ //noinspection JSUnusedLocalSymbols
941
+ jasmine.Reporter.prototype.reportSpecStarting = function(spec) {
942
+ };
943
+
944
+ //noinspection JSUnusedLocalSymbols
945
+ jasmine.Reporter.prototype.reportSpecResults = function(spec) {
946
+ };
947
+
948
+ //noinspection JSUnusedLocalSymbols
949
+ jasmine.Reporter.prototype.log = function(str) {
950
+ };
951
+
952
+ /**
953
+ * Blocks are functions with executable code that make up a spec.
954
+ *
955
+ * @constructor
956
+ * @param {jasmine.Env} env
957
+ * @param {Function} func
958
+ * @param {jasmine.Spec} spec
959
+ */
960
+ jasmine.Block = function(env, func, spec) {
961
+ this.env = env;
962
+ this.func = func;
963
+ this.spec = spec;
964
+ };
965
+
966
+ jasmine.Block.prototype.execute = function(onComplete) {
967
+ try {
968
+ this.func.apply(this.spec);
969
+ } catch (e) {
970
+ this.spec.fail(e);
971
+ }
972
+ onComplete();
973
+ };
974
+ /** JavaScript API reporter.
975
+ *
976
+ * @constructor
977
+ */
978
+ jasmine.JsApiReporter = function() {
979
+ this.started = false;
980
+ this.finished = false;
981
+ this.suites_ = [];
982
+ this.results_ = {};
983
+ };
984
+
985
+ jasmine.JsApiReporter.prototype.reportRunnerStarting = function(runner) {
986
+ this.started = true;
987
+ var suites = runner.topLevelSuites();
988
+ for (var i = 0; i < suites.length; i++) {
989
+ var suite = suites[i];
990
+ this.suites_.push(this.summarize_(suite));
991
+ }
992
+ };
993
+
994
+ jasmine.JsApiReporter.prototype.suites = function() {
995
+ return this.suites_;
996
+ };
997
+
998
+ jasmine.JsApiReporter.prototype.summarize_ = function(suiteOrSpec) {
999
+ var isSuite = suiteOrSpec instanceof jasmine.Suite;
1000
+ var summary = {
1001
+ id: suiteOrSpec.id,
1002
+ name: suiteOrSpec.description,
1003
+ type: isSuite ? 'suite' : 'spec',
1004
+ children: []
1005
+ };
1006
+
1007
+ if (isSuite) {
1008
+ var children = suiteOrSpec.children();
1009
+ for (var i = 0; i < children.length; i++) {
1010
+ summary.children.push(this.summarize_(children[i]));
1011
+ }
1012
+ }
1013
+ return summary;
1014
+ };
1015
+
1016
+ jasmine.JsApiReporter.prototype.results = function() {
1017
+ return this.results_;
1018
+ };
1019
+
1020
+ jasmine.JsApiReporter.prototype.resultsForSpec = function(specId) {
1021
+ return this.results_[specId];
1022
+ };
1023
+
1024
+ //noinspection JSUnusedLocalSymbols
1025
+ jasmine.JsApiReporter.prototype.reportRunnerResults = function(runner) {
1026
+ this.finished = true;
1027
+ };
1028
+
1029
+ //noinspection JSUnusedLocalSymbols
1030
+ jasmine.JsApiReporter.prototype.reportSuiteResults = function(suite) {
1031
+ };
1032
+
1033
+ //noinspection JSUnusedLocalSymbols
1034
+ jasmine.JsApiReporter.prototype.reportSpecResults = function(spec) {
1035
+ this.results_[spec.id] = {
1036
+ messages: spec.results().getItems(),
1037
+ result: spec.results().failedCount > 0 ? "failed" : "passed"
1038
+ };
1039
+ };
1040
+
1041
+ //noinspection JSUnusedLocalSymbols
1042
+ jasmine.JsApiReporter.prototype.log = function(str) {
1043
+ };
1044
+
1045
+ jasmine.JsApiReporter.prototype.resultsForSpecs = function(specIds){
1046
+ var results = {};
1047
+ for (var i = 0; i < specIds.length; i++) {
1048
+ var specId = specIds[i];
1049
+ results[specId] = this.summarizeResult_(this.results_[specId]);
1050
+ }
1051
+ return results;
1052
+ };
1053
+
1054
+ jasmine.JsApiReporter.prototype.summarizeResult_ = function(result){
1055
+ var summaryMessages = [];
1056
+ var messagesLength = result.messages.length;
1057
+ for (var messageIndex = 0; messageIndex < messagesLength; messageIndex++) {
1058
+ var resultMessage = result.messages[messageIndex];
1059
+ summaryMessages.push({
1060
+ text: resultMessage.type == 'log' ? resultMessage.toString() : jasmine.undefined,
1061
+ passed: resultMessage.passed ? resultMessage.passed() : true,
1062
+ type: resultMessage.type,
1063
+ message: resultMessage.message,
1064
+ trace: {
1065
+ stack: resultMessage.passed && !resultMessage.passed() ? resultMessage.trace.stack : jasmine.undefined
1066
+ }
1067
+ });
1068
+ }
1069
+
1070
+ return {
1071
+ result : result.result,
1072
+ messages : summaryMessages
1073
+ };
1074
+ };
1075
+
1076
+ /**
1077
+ * @constructor
1078
+ * @param {jasmine.Env} env
1079
+ * @param actual
1080
+ * @param {jasmine.Spec} spec
1081
+ */
1082
+ jasmine.Matchers = function(env, actual, spec, opt_isNot) {
1083
+ this.env = env;
1084
+ this.actual = actual;
1085
+ this.spec = spec;
1086
+ this.isNot = opt_isNot || false;
1087
+ this.reportWasCalled_ = false;
1088
+ };
1089
+
1090
+ // todo: @deprecated as of Jasmine 0.11, remove soon [xw]
1091
+ jasmine.Matchers.pp = function(str) {
1092
+ throw new Error("jasmine.Matchers.pp() is no longer supported, please use jasmine.pp() instead!");
1093
+ };
1094
+
1095
+ // todo: @deprecated Deprecated as of Jasmine 0.10. Rewrite your custom matchers to return true or false. [xw]
1096
+ jasmine.Matchers.prototype.report = function(result, failing_message, details) {
1097
+ throw new Error("As of jasmine 0.11, custom matchers must be implemented differently -- please see jasmine docs");
1098
+ };
1099
+
1100
+ jasmine.Matchers.wrapInto_ = function(prototype, matchersClass) {
1101
+ for (var methodName in prototype) {
1102
+ if (methodName == 'report') continue;
1103
+ var orig = prototype[methodName];
1104
+ matchersClass.prototype[methodName] = jasmine.Matchers.matcherFn_(methodName, orig);
1105
+ }
1106
+ };
1107
+
1108
+ jasmine.Matchers.matcherFn_ = function(matcherName, matcherFunction) {
1109
+ return function() {
1110
+ var matcherArgs = jasmine.util.argsToArray(arguments);
1111
+ var result = matcherFunction.apply(this, arguments);
1112
+
1113
+ if (this.isNot) {
1114
+ result = !result;
1115
+ }
1116
+
1117
+ if (this.reportWasCalled_) return result;
1118
+
1119
+ var message;
1120
+ if (!result) {
1121
+ if (this.message) {
1122
+ message = this.message.apply(this, arguments);
1123
+ if (jasmine.isArray_(message)) {
1124
+ message = message[this.isNot ? 1 : 0];
1125
+ }
1126
+ } else {
1127
+ var englishyPredicate = matcherName.replace(/[A-Z]/g, function(s) { return ' ' + s.toLowerCase(); });
1128
+ message = "Expected " + jasmine.pp(this.actual) + (this.isNot ? " not " : " ") + englishyPredicate;
1129
+ if (matcherArgs.length > 0) {
1130
+ for (var i = 0; i < matcherArgs.length; i++) {
1131
+ if (i > 0) message += ",";
1132
+ message += " " + jasmine.pp(matcherArgs[i]);
1133
+ }
1134
+ }
1135
+ message += ".";
1136
+ }
1137
+ }
1138
+ var expectationResult = new jasmine.ExpectationResult({
1139
+ matcherName: matcherName,
1140
+ passed: result,
1141
+ expected: matcherArgs.length > 1 ? matcherArgs : matcherArgs[0],
1142
+ actual: this.actual,
1143
+ message: message
1144
+ });
1145
+ this.spec.addMatcherResult(expectationResult);
1146
+ return jasmine.undefined;
1147
+ };
1148
+ };
1149
+
1150
+
1151
+
1152
+
1153
+ /**
1154
+ * toBe: compares the actual to the expected using ===
1155
+ * @param expected
1156
+ */
1157
+ jasmine.Matchers.prototype.toBe = function(expected) {
1158
+ return this.actual === expected;
1159
+ };
1160
+
1161
+ /**
1162
+ * toNotBe: compares the actual to the expected using !==
1163
+ * @param expected
1164
+ * @deprecated as of 1.0. Use not.toBe() instead.
1165
+ */
1166
+ jasmine.Matchers.prototype.toNotBe = function(expected) {
1167
+ return this.actual !== expected;
1168
+ };
1169
+
1170
+ /**
1171
+ * toEqual: compares the actual to the expected using common sense equality. Handles Objects, Arrays, etc.
1172
+ *
1173
+ * @param expected
1174
+ */
1175
+ jasmine.Matchers.prototype.toEqual = function(expected) {
1176
+ return this.env.equals_(this.actual, expected);
1177
+ };
1178
+
1179
+ /**
1180
+ * toNotEqual: compares the actual to the expected using the ! of jasmine.Matchers.toEqual
1181
+ * @param expected
1182
+ * @deprecated as of 1.0. Use not.toNotEqual() instead.
1183
+ */
1184
+ jasmine.Matchers.prototype.toNotEqual = function(expected) {
1185
+ return !this.env.equals_(this.actual, expected);
1186
+ };
1187
+
1188
+ /**
1189
+ * Matcher that compares the actual to the expected using a regular expression. Constructs a RegExp, so takes
1190
+ * a pattern or a String.
1191
+ *
1192
+ * @param expected
1193
+ */
1194
+ jasmine.Matchers.prototype.toMatch = function(expected) {
1195
+ return new RegExp(expected).test(this.actual);
1196
+ };
1197
+
1198
+ /**
1199
+ * Matcher that compares the actual to the expected using the boolean inverse of jasmine.Matchers.toMatch
1200
+ * @param expected
1201
+ * @deprecated as of 1.0. Use not.toMatch() instead.
1202
+ */
1203
+ jasmine.Matchers.prototype.toNotMatch = function(expected) {
1204
+ return !(new RegExp(expected).test(this.actual));
1205
+ };
1206
+
1207
+ /**
1208
+ * Matcher that compares the actual to jasmine.undefined.
1209
+ */
1210
+ jasmine.Matchers.prototype.toBeDefined = function() {
1211
+ return (this.actual !== jasmine.undefined);
1212
+ };
1213
+
1214
+ /**
1215
+ * Matcher that compares the actual to jasmine.undefined.
1216
+ */
1217
+ jasmine.Matchers.prototype.toBeUndefined = function() {
1218
+ return (this.actual === jasmine.undefined);
1219
+ };
1220
+
1221
+ /**
1222
+ * Matcher that compares the actual to null.
1223
+ */
1224
+ jasmine.Matchers.prototype.toBeNull = function() {
1225
+ return (this.actual === null);
1226
+ };
1227
+
1228
+ /**
1229
+ * Matcher that boolean not-nots the actual.
1230
+ */
1231
+ jasmine.Matchers.prototype.toBeTruthy = function() {
1232
+ return !!this.actual;
1233
+ };
1234
+
1235
+
1236
+ /**
1237
+ * Matcher that boolean nots the actual.
1238
+ */
1239
+ jasmine.Matchers.prototype.toBeFalsy = function() {
1240
+ return !this.actual;
1241
+ };
1242
+
1243
+
1244
+ /**
1245
+ * Matcher that checks to see if the actual, a Jasmine spy, was called.
1246
+ */
1247
+ jasmine.Matchers.prototype.toHaveBeenCalled = function() {
1248
+ if (arguments.length > 0) {
1249
+ throw new Error('toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith');
1250
+ }
1251
+
1252
+ if (!jasmine.isSpy(this.actual)) {
1253
+ throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
1254
+ }
1255
+
1256
+ this.message = function() {
1257
+ return [
1258
+ "Expected spy " + this.actual.identity + " to have been called.",
1259
+ "Expected spy " + this.actual.identity + " not to have been called."
1260
+ ];
1261
+ };
1262
+
1263
+ return this.actual.wasCalled;
1264
+ };
1265
+
1266
+ /** @deprecated Use expect(xxx).toHaveBeenCalled() instead */
1267
+ jasmine.Matchers.prototype.wasCalled = jasmine.Matchers.prototype.toHaveBeenCalled;
1268
+
1269
+ /**
1270
+ * Matcher that checks to see if the actual, a Jasmine spy, was not called.
1271
+ *
1272
+ * @deprecated Use expect(xxx).not.toHaveBeenCalled() instead
1273
+ */
1274
+ jasmine.Matchers.prototype.wasNotCalled = function() {
1275
+ if (arguments.length > 0) {
1276
+ throw new Error('wasNotCalled does not take arguments');
1277
+ }
1278
+
1279
+ if (!jasmine.isSpy(this.actual)) {
1280
+ throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
1281
+ }
1282
+
1283
+ this.message = function() {
1284
+ return [
1285
+ "Expected spy " + this.actual.identity + " to not have been called.",
1286
+ "Expected spy " + this.actual.identity + " to have been called."
1287
+ ];
1288
+ };
1289
+
1290
+ return !this.actual.wasCalled;
1291
+ };
1292
+
1293
+ /**
1294
+ * Matcher that checks to see if the actual, a Jasmine spy, was called with a set of parameters.
1295
+ *
1296
+ * @example
1297
+ *
1298
+ */
1299
+ jasmine.Matchers.prototype.toHaveBeenCalledWith = function() {
1300
+ var expectedArgs = jasmine.util.argsToArray(arguments);
1301
+ if (!jasmine.isSpy(this.actual)) {
1302
+ throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
1303
+ }
1304
+ this.message = function() {
1305
+ if (this.actual.callCount == 0) {
1306
+ // todo: what should the failure message for .not.toHaveBeenCalledWith() be? is this right? test better. [xw]
1307
+ return [
1308
+ "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but it was never called.",
1309
+ "Expected spy not to have been called with " + jasmine.pp(expectedArgs) + " but it was."
1310
+ ];
1311
+ } else {
1312
+ return [
1313
+ "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but was called with " + jasmine.pp(this.actual.argsForCall),
1314
+ "Expected spy not to have been called with " + jasmine.pp(expectedArgs) + " but was called with " + jasmine.pp(this.actual.argsForCall)
1315
+ ];
1316
+ }
1317
+ };
1318
+
1319
+ return this.env.contains_(this.actual.argsForCall, expectedArgs);
1320
+ };
1321
+
1322
+ /** @deprecated Use expect(xxx).toHaveBeenCalledWith() instead */
1323
+ jasmine.Matchers.prototype.wasCalledWith = jasmine.Matchers.prototype.toHaveBeenCalledWith;
1324
+
1325
+ /** @deprecated Use expect(xxx).not.toHaveBeenCalledWith() instead */
1326
+ jasmine.Matchers.prototype.wasNotCalledWith = function() {
1327
+ var expectedArgs = jasmine.util.argsToArray(arguments);
1328
+ if (!jasmine.isSpy(this.actual)) {
1329
+ throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
1330
+ }
1331
+
1332
+ this.message = function() {
1333
+ return [
1334
+ "Expected spy not to have been called with " + jasmine.pp(expectedArgs) + " but it was",
1335
+ "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but it was"
1336
+ ]
1337
+ };
1338
+
1339
+ return !this.env.contains_(this.actual.argsForCall, expectedArgs);
1340
+ };
1341
+
1342
+ /**
1343
+ * Matcher that checks that the expected item is an element in the actual Array.
1344
+ *
1345
+ * @param {Object} expected
1346
+ */
1347
+ jasmine.Matchers.prototype.toContain = function(expected) {
1348
+ return this.env.contains_(this.actual, expected);
1349
+ };
1350
+
1351
+ /**
1352
+ * Matcher that checks that the expected item is NOT an element in the actual Array.
1353
+ *
1354
+ * @param {Object} expected
1355
+ * @deprecated as of 1.0. Use not.toNotContain() instead.
1356
+ */
1357
+ jasmine.Matchers.prototype.toNotContain = function(expected) {
1358
+ return !this.env.contains_(this.actual, expected);
1359
+ };
1360
+
1361
+ jasmine.Matchers.prototype.toBeLessThan = function(expected) {
1362
+ return this.actual < expected;
1363
+ };
1364
+
1365
+ jasmine.Matchers.prototype.toBeGreaterThan = function(expected) {
1366
+ return this.actual > expected;
1367
+ };
1368
+
1369
+ /**
1370
+ * Matcher that checks that the expected exception was thrown by the actual.
1371
+ *
1372
+ * @param {String} expected
1373
+ */
1374
+ jasmine.Matchers.prototype.toThrow = function(expected) {
1375
+ var result = false;
1376
+ var exception;
1377
+ if (typeof this.actual != 'function') {
1378
+ throw new Error('Actual is not a function');
1379
+ }
1380
+ try {
1381
+ this.actual();
1382
+ } catch (e) {
1383
+ exception = e;
1384
+ }
1385
+ if (exception) {
1386
+ result = (expected === jasmine.undefined || this.env.equals_(exception.message || exception, expected.message || expected));
1387
+ }
1388
+
1389
+ var not = this.isNot ? "not " : "";
1390
+
1391
+ this.message = function() {
1392
+ if (exception && (expected === jasmine.undefined || !this.env.equals_(exception.message || exception, expected.message || expected))) {
1393
+ return ["Expected function " + not + "to throw", expected ? expected.message || expected : " an exception", ", but it threw", exception.message || exception].join(' ');
1394
+ } else {
1395
+ return "Expected function to throw an exception.";
1396
+ }
1397
+ };
1398
+
1399
+ return result;
1400
+ };
1401
+
1402
+ jasmine.Matchers.Any = function(expectedClass) {
1403
+ this.expectedClass = expectedClass;
1404
+ };
1405
+
1406
+ jasmine.Matchers.Any.prototype.matches = function(other) {
1407
+ if (this.expectedClass == String) {
1408
+ return typeof other == 'string' || other instanceof String;
1409
+ }
1410
+
1411
+ if (this.expectedClass == Number) {
1412
+ return typeof other == 'number' || other instanceof Number;
1413
+ }
1414
+
1415
+ if (this.expectedClass == Function) {
1416
+ return typeof other == 'function' || other instanceof Function;
1417
+ }
1418
+
1419
+ if (this.expectedClass == Object) {
1420
+ return typeof other == 'object';
1421
+ }
1422
+
1423
+ return other instanceof this.expectedClass;
1424
+ };
1425
+
1426
+ jasmine.Matchers.Any.prototype.toString = function() {
1427
+ return '<jasmine.any(' + this.expectedClass + ')>';
1428
+ };
1429
+
1430
+ /**
1431
+ * @constructor
1432
+ */
1433
+ jasmine.MultiReporter = function() {
1434
+ this.subReporters_ = [];
1435
+ };
1436
+ jasmine.util.inherit(jasmine.MultiReporter, jasmine.Reporter);
1437
+
1438
+ jasmine.MultiReporter.prototype.addReporter = function(reporter) {
1439
+ this.subReporters_.push(reporter);
1440
+ };
1441
+
1442
+ (function() {
1443
+ var functionNames = [
1444
+ "reportRunnerStarting",
1445
+ "reportRunnerResults",
1446
+ "reportSuiteResults",
1447
+ "reportSpecStarting",
1448
+ "reportSpecResults",
1449
+ "log"
1450
+ ];
1451
+ for (var i = 0; i < functionNames.length; i++) {
1452
+ var functionName = functionNames[i];
1453
+ jasmine.MultiReporter.prototype[functionName] = (function(functionName) {
1454
+ return function() {
1455
+ for (var j = 0; j < this.subReporters_.length; j++) {
1456
+ var subReporter = this.subReporters_[j];
1457
+ if (subReporter[functionName]) {
1458
+ subReporter[functionName].apply(subReporter, arguments);
1459
+ }
1460
+ }
1461
+ };
1462
+ })(functionName);
1463
+ }
1464
+ })();
1465
+ /**
1466
+ * Holds results for a set of Jasmine spec. Allows for the results array to hold another jasmine.NestedResults
1467
+ *
1468
+ * @constructor
1469
+ */
1470
+ jasmine.NestedResults = function() {
1471
+ /**
1472
+ * The total count of results
1473
+ */
1474
+ this.totalCount = 0;
1475
+ /**
1476
+ * Number of passed results
1477
+ */
1478
+ this.passedCount = 0;
1479
+ /**
1480
+ * Number of failed results
1481
+ */
1482
+ this.failedCount = 0;
1483
+ /**
1484
+ * Was this suite/spec skipped?
1485
+ */
1486
+ this.skipped = false;
1487
+ /**
1488
+ * @ignore
1489
+ */
1490
+ this.items_ = [];
1491
+ };
1492
+
1493
+ /**
1494
+ * Roll up the result counts.
1495
+ *
1496
+ * @param result
1497
+ */
1498
+ jasmine.NestedResults.prototype.rollupCounts = function(result) {
1499
+ this.totalCount += result.totalCount;
1500
+ this.passedCount += result.passedCount;
1501
+ this.failedCount += result.failedCount;
1502
+ };
1503
+
1504
+ /**
1505
+ * Adds a log message.
1506
+ * @param values Array of message parts which will be concatenated later.
1507
+ */
1508
+ jasmine.NestedResults.prototype.log = function(values) {
1509
+ this.items_.push(new jasmine.MessageResult(values));
1510
+ };
1511
+
1512
+ /**
1513
+ * Getter for the results: message & results.
1514
+ */
1515
+ jasmine.NestedResults.prototype.getItems = function() {
1516
+ return this.items_;
1517
+ };
1518
+
1519
+ /**
1520
+ * Adds a result, tracking counts (total, passed, & failed)
1521
+ * @param {jasmine.ExpectationResult|jasmine.NestedResults} result
1522
+ */
1523
+ jasmine.NestedResults.prototype.addResult = function(result) {
1524
+ if (result.type != 'log') {
1525
+ if (result.items_) {
1526
+ this.rollupCounts(result);
1527
+ } else {
1528
+ this.totalCount++;
1529
+ if (result.passed()) {
1530
+ this.passedCount++;
1531
+ } else {
1532
+ this.failedCount++;
1533
+ }
1534
+ }
1535
+ }
1536
+ this.items_.push(result);
1537
+ };
1538
+
1539
+ /**
1540
+ * @returns {Boolean} True if <b>everything</b> below passed
1541
+ */
1542
+ jasmine.NestedResults.prototype.passed = function() {
1543
+ return this.passedCount === this.totalCount;
1544
+ };
1545
+ /**
1546
+ * Base class for pretty printing for expectation results.
1547
+ */
1548
+ jasmine.PrettyPrinter = function() {
1549
+ this.ppNestLevel_ = 0;
1550
+ };
1551
+
1552
+ /**
1553
+ * Formats a value in a nice, human-readable string.
1554
+ *
1555
+ * @param value
1556
+ */
1557
+ jasmine.PrettyPrinter.prototype.format = function(value) {
1558
+ if (this.ppNestLevel_ > 40) {
1559
+ throw new Error('jasmine.PrettyPrinter: format() nested too deeply!');
1560
+ }
1561
+
1562
+ this.ppNestLevel_++;
1563
+ try {
1564
+ if (value === jasmine.undefined) {
1565
+ this.emitScalar('undefined');
1566
+ } else if (value === null) {
1567
+ this.emitScalar('null');
1568
+ } else if (value === jasmine.getGlobal()) {
1569
+ this.emitScalar('<global>');
1570
+ } else if (value instanceof jasmine.Matchers.Any) {
1571
+ this.emitScalar(value.toString());
1572
+ } else if (typeof value === 'string') {
1573
+ this.emitString(value);
1574
+ } else if (jasmine.isSpy(value)) {
1575
+ this.emitScalar("spy on " + value.identity);
1576
+ } else if (value instanceof RegExp) {
1577
+ this.emitScalar(value.toString());
1578
+ } else if (typeof value === 'function') {
1579
+ this.emitScalar('Function');
1580
+ } else if (typeof value.nodeType === 'number') {
1581
+ this.emitScalar('HTMLNode');
1582
+ } else if (value instanceof Date) {
1583
+ this.emitScalar('Date(' + value + ')');
1584
+ } else if (value.__Jasmine_been_here_before__) {
1585
+ this.emitScalar('<circular reference: ' + (jasmine.isArray_(value) ? 'Array' : 'Object') + '>');
1586
+ } else if (jasmine.isArray_(value) || typeof value == 'object') {
1587
+ value.__Jasmine_been_here_before__ = true;
1588
+ if (jasmine.isArray_(value)) {
1589
+ this.emitArray(value);
1590
+ } else {
1591
+ this.emitObject(value);
1592
+ }
1593
+ delete value.__Jasmine_been_here_before__;
1594
+ } else {
1595
+ this.emitScalar(value.toString());
1596
+ }
1597
+ } finally {
1598
+ this.ppNestLevel_--;
1599
+ }
1600
+ };
1601
+
1602
+ jasmine.PrettyPrinter.prototype.iterateObject = function(obj, fn) {
1603
+ for (var property in obj) {
1604
+ if (property == '__Jasmine_been_here_before__') continue;
1605
+ fn(property, obj.__lookupGetter__ ? (obj.__lookupGetter__(property) != null) : false);
1606
+ }
1607
+ };
1608
+
1609
+ jasmine.PrettyPrinter.prototype.emitArray = jasmine.unimplementedMethod_;
1610
+ jasmine.PrettyPrinter.prototype.emitObject = jasmine.unimplementedMethod_;
1611
+ jasmine.PrettyPrinter.prototype.emitScalar = jasmine.unimplementedMethod_;
1612
+ jasmine.PrettyPrinter.prototype.emitString = jasmine.unimplementedMethod_;
1613
+
1614
+ jasmine.StringPrettyPrinter = function() {
1615
+ jasmine.PrettyPrinter.call(this);
1616
+
1617
+ this.string = '';
1618
+ };
1619
+ jasmine.util.inherit(jasmine.StringPrettyPrinter, jasmine.PrettyPrinter);
1620
+
1621
+ jasmine.StringPrettyPrinter.prototype.emitScalar = function(value) {
1622
+ this.append(value);
1623
+ };
1624
+
1625
+ jasmine.StringPrettyPrinter.prototype.emitString = function(value) {
1626
+ this.append("'" + value + "'");
1627
+ };
1628
+
1629
+ jasmine.StringPrettyPrinter.prototype.emitArray = function(array) {
1630
+ this.append('[ ');
1631
+ for (var i = 0; i < array.length; i++) {
1632
+ if (i > 0) {
1633
+ this.append(', ');
1634
+ }
1635
+ this.format(array[i]);
1636
+ }
1637
+ this.append(' ]');
1638
+ };
1639
+
1640
+ jasmine.StringPrettyPrinter.prototype.emitObject = function(obj) {
1641
+ var self = this;
1642
+ this.append('{ ');
1643
+ var first = true;
1644
+
1645
+ this.iterateObject(obj, function(property, isGetter) {
1646
+ if (first) {
1647
+ first = false;
1648
+ } else {
1649
+ self.append(', ');
1650
+ }
1651
+
1652
+ self.append(property);
1653
+ self.append(' : ');
1654
+ if (isGetter) {
1655
+ self.append('<getter>');
1656
+ } else {
1657
+ self.format(obj[property]);
1658
+ }
1659
+ });
1660
+
1661
+ this.append(' }');
1662
+ };
1663
+
1664
+ jasmine.StringPrettyPrinter.prototype.append = function(value) {
1665
+ this.string += value;
1666
+ };
1667
+ jasmine.Queue = function(env) {
1668
+ this.env = env;
1669
+ this.blocks = [];
1670
+ this.running = false;
1671
+ this.index = 0;
1672
+ this.offset = 0;
1673
+ this.abort = false;
1674
+ };
1675
+
1676
+ jasmine.Queue.prototype.addBefore = function(block) {
1677
+ this.blocks.unshift(block);
1678
+ };
1679
+
1680
+ jasmine.Queue.prototype.add = function(block) {
1681
+ this.blocks.push(block);
1682
+ };
1683
+
1684
+ jasmine.Queue.prototype.insertNext = function(block) {
1685
+ this.blocks.splice((this.index + this.offset + 1), 0, block);
1686
+ this.offset++;
1687
+ };
1688
+
1689
+ jasmine.Queue.prototype.start = function(onComplete) {
1690
+ this.running = true;
1691
+ this.onComplete = onComplete;
1692
+ this.next_();
1693
+ };
1694
+
1695
+ jasmine.Queue.prototype.isRunning = function() {
1696
+ return this.running;
1697
+ };
1698
+
1699
+ jasmine.Queue.LOOP_DONT_RECURSE = true;
1700
+
1701
+ jasmine.Queue.prototype.next_ = function() {
1702
+ var self = this;
1703
+ var goAgain = true;
1704
+
1705
+ while (goAgain) {
1706
+ goAgain = false;
1707
+
1708
+ if (self.index < self.blocks.length && !this.abort) {
1709
+ var calledSynchronously = true;
1710
+ var completedSynchronously = false;
1711
+
1712
+ var onComplete = function () {
1713
+ if (jasmine.Queue.LOOP_DONT_RECURSE && calledSynchronously) {
1714
+ completedSynchronously = true;
1715
+ return;
1716
+ }
1717
+
1718
+ if (self.blocks[self.index].abort) {
1719
+ self.abort = true;
1720
+ }
1721
+
1722
+ self.offset = 0;
1723
+ self.index++;
1724
+
1725
+ var now = new Date().getTime();
1726
+ if (self.env.updateInterval && now - self.env.lastUpdate > self.env.updateInterval) {
1727
+ self.env.lastUpdate = now;
1728
+ self.env.setTimeout(function() {
1729
+ self.next_();
1730
+ }, 0);
1731
+ } else {
1732
+ if (jasmine.Queue.LOOP_DONT_RECURSE && completedSynchronously) {
1733
+ goAgain = true;
1734
+ } else {
1735
+ self.next_();
1736
+ }
1737
+ }
1738
+ };
1739
+ self.blocks[self.index].execute(onComplete);
1740
+
1741
+ calledSynchronously = false;
1742
+ if (completedSynchronously) {
1743
+ onComplete();
1744
+ }
1745
+
1746
+ } else {
1747
+ self.running = false;
1748
+ if (self.onComplete) {
1749
+ self.onComplete();
1750
+ }
1751
+ }
1752
+ }
1753
+ };
1754
+
1755
+ jasmine.Queue.prototype.results = function() {
1756
+ var results = new jasmine.NestedResults();
1757
+ for (var i = 0; i < this.blocks.length; i++) {
1758
+ if (this.blocks[i].results) {
1759
+ results.addResult(this.blocks[i].results());
1760
+ }
1761
+ }
1762
+ return results;
1763
+ };
1764
+
1765
+
1766
+ /**
1767
+ * Runner
1768
+ *
1769
+ * @constructor
1770
+ * @param {jasmine.Env} env
1771
+ */
1772
+ jasmine.Runner = function(env) {
1773
+ var self = this;
1774
+ self.env = env;
1775
+ self.queue = new jasmine.Queue(env);
1776
+ self.before_ = [];
1777
+ self.after_ = [];
1778
+ self.suites_ = [];
1779
+ };
1780
+
1781
+ jasmine.Runner.prototype.execute = function() {
1782
+ var self = this;
1783
+ if (self.env.reporter.reportRunnerStarting) {
1784
+ self.env.reporter.reportRunnerStarting(this);
1785
+ }
1786
+ self.queue.start(function () {
1787
+ self.finishCallback();
1788
+ });
1789
+ };
1790
+
1791
+ jasmine.Runner.prototype.beforeEach = function(beforeEachFunction) {
1792
+ beforeEachFunction.typeName = 'beforeEach';
1793
+ this.before_.splice(0,0,beforeEachFunction);
1794
+ };
1795
+
1796
+ jasmine.Runner.prototype.afterEach = function(afterEachFunction) {
1797
+ afterEachFunction.typeName = 'afterEach';
1798
+ this.after_.splice(0,0,afterEachFunction);
1799
+ };
1800
+
1801
+
1802
+ jasmine.Runner.prototype.finishCallback = function() {
1803
+ this.env.reporter.reportRunnerResults(this);
1804
+ };
1805
+
1806
+ jasmine.Runner.prototype.addSuite = function(suite) {
1807
+ this.suites_.push(suite);
1808
+ };
1809
+
1810
+ jasmine.Runner.prototype.add = function(block) {
1811
+ if (block instanceof jasmine.Suite) {
1812
+ this.addSuite(block);
1813
+ }
1814
+ this.queue.add(block);
1815
+ };
1816
+
1817
+ jasmine.Runner.prototype.specs = function () {
1818
+ var suites = this.suites();
1819
+ var specs = [];
1820
+ for (var i = 0; i < suites.length; i++) {
1821
+ specs = specs.concat(suites[i].specs());
1822
+ }
1823
+ return specs;
1824
+ };
1825
+
1826
+ jasmine.Runner.prototype.suites = function() {
1827
+ return this.suites_;
1828
+ };
1829
+
1830
+ jasmine.Runner.prototype.topLevelSuites = function() {
1831
+ var topLevelSuites = [];
1832
+ for (var i = 0; i < this.suites_.length; i++) {
1833
+ if (!this.suites_[i].parentSuite) {
1834
+ topLevelSuites.push(this.suites_[i]);
1835
+ }
1836
+ }
1837
+ return topLevelSuites;
1838
+ };
1839
+
1840
+ jasmine.Runner.prototype.results = function() {
1841
+ return this.queue.results();
1842
+ };
1843
+ /**
1844
+ * Internal representation of a Jasmine specification, or test.
1845
+ *
1846
+ * @constructor
1847
+ * @param {jasmine.Env} env
1848
+ * @param {jasmine.Suite} suite
1849
+ * @param {String} description
1850
+ */
1851
+ jasmine.Spec = function(env, suite, description) {
1852
+ if (!env) {
1853
+ throw new Error('jasmine.Env() required');
1854
+ }
1855
+ if (!suite) {
1856
+ throw new Error('jasmine.Suite() required');
1857
+ }
1858
+ var spec = this;
1859
+ spec.id = env.nextSpecId ? env.nextSpecId() : null;
1860
+ spec.env = env;
1861
+ spec.suite = suite;
1862
+ spec.description = description;
1863
+ spec.queue = new jasmine.Queue(env);
1864
+
1865
+ spec.afterCallbacks = [];
1866
+ spec.spies_ = [];
1867
+
1868
+ spec.results_ = new jasmine.NestedResults();
1869
+ spec.results_.description = description;
1870
+ spec.matchersClass = null;
1871
+ };
1872
+
1873
+ jasmine.Spec.prototype.getFullName = function() {
1874
+ return this.suite.getFullName() + ' ' + this.description + '.';
1875
+ };
1876
+
1877
+
1878
+ jasmine.Spec.prototype.results = function() {
1879
+ return this.results_;
1880
+ };
1881
+
1882
+ /**
1883
+ * All parameters are pretty-printed and concatenated together, then written to the spec's output.
1884
+ *
1885
+ * Be careful not to leave calls to <code>jasmine.log</code> in production code.
1886
+ */
1887
+ jasmine.Spec.prototype.log = function() {
1888
+ return this.results_.log(arguments);
1889
+ };
1890
+
1891
+ jasmine.Spec.prototype.runs = function (func) {
1892
+ var block = new jasmine.Block(this.env, func, this);
1893
+ this.addToQueue(block);
1894
+ return this;
1895
+ };
1896
+
1897
+ jasmine.Spec.prototype.addToQueue = function (block) {
1898
+ if (this.queue.isRunning()) {
1899
+ this.queue.insertNext(block);
1900
+ } else {
1901
+ this.queue.add(block);
1902
+ }
1903
+ };
1904
+
1905
+ /**
1906
+ * @param {jasmine.ExpectationResult} result
1907
+ */
1908
+ jasmine.Spec.prototype.addMatcherResult = function(result) {
1909
+ this.results_.addResult(result);
1910
+ };
1911
+
1912
+ jasmine.Spec.prototype.expect = function(actual) {
1913
+ var positive = new (this.getMatchersClass_())(this.env, actual, this);
1914
+ positive.not = new (this.getMatchersClass_())(this.env, actual, this, true);
1915
+ return positive;
1916
+ };
1917
+
1918
+ /**
1919
+ * Waits a fixed time period before moving to the next block.
1920
+ *
1921
+ * @deprecated Use waitsFor() instead
1922
+ * @param {Number} timeout milliseconds to wait
1923
+ */
1924
+ jasmine.Spec.prototype.waits = function(timeout) {
1925
+ var waitsFunc = new jasmine.WaitsBlock(this.env, timeout, this);
1926
+ this.addToQueue(waitsFunc);
1927
+ return this;
1928
+ };
1929
+
1930
+ /**
1931
+ * Waits for the latchFunction to return true before proceeding to the next block.
1932
+ *
1933
+ * @param {Function} latchFunction
1934
+ * @param {String} optional_timeoutMessage
1935
+ * @param {Number} optional_timeout
1936
+ */
1937
+ jasmine.Spec.prototype.waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) {
1938
+ var latchFunction_ = null;
1939
+ var optional_timeoutMessage_ = null;
1940
+ var optional_timeout_ = null;
1941
+
1942
+ for (var i = 0; i < arguments.length; i++) {
1943
+ var arg = arguments[i];
1944
+ switch (typeof arg) {
1945
+ case 'function':
1946
+ latchFunction_ = arg;
1947
+ break;
1948
+ case 'string':
1949
+ optional_timeoutMessage_ = arg;
1950
+ break;
1951
+ case 'number':
1952
+ optional_timeout_ = arg;
1953
+ break;
1954
+ }
1955
+ }
1956
+
1957
+ var waitsForFunc = new jasmine.WaitsForBlock(this.env, optional_timeout_, latchFunction_, optional_timeoutMessage_, this);
1958
+ this.addToQueue(waitsForFunc);
1959
+ return this;
1960
+ };
1961
+
1962
+ jasmine.Spec.prototype.fail = function (e) {
1963
+ var expectationResult = new jasmine.ExpectationResult({
1964
+ passed: false,
1965
+ message: e ? jasmine.util.formatException(e) : 'Exception'
1966
+ });
1967
+ this.results_.addResult(expectationResult);
1968
+ };
1969
+
1970
+ jasmine.Spec.prototype.getMatchersClass_ = function() {
1971
+ return this.matchersClass || this.env.matchersClass;
1972
+ };
1973
+
1974
+ jasmine.Spec.prototype.addMatchers = function(matchersPrototype) {
1975
+ var parent = this.getMatchersClass_();
1976
+ var newMatchersClass = function() {
1977
+ parent.apply(this, arguments);
1978
+ };
1979
+ jasmine.util.inherit(newMatchersClass, parent);
1980
+ jasmine.Matchers.wrapInto_(matchersPrototype, newMatchersClass);
1981
+ this.matchersClass = newMatchersClass;
1982
+ };
1983
+
1984
+ jasmine.Spec.prototype.finishCallback = function() {
1985
+ this.env.reporter.reportSpecResults(this);
1986
+ };
1987
+
1988
+ jasmine.Spec.prototype.finish = function(onComplete) {
1989
+ this.removeAllSpies();
1990
+ this.finishCallback();
1991
+ if (onComplete) {
1992
+ onComplete();
1993
+ }
1994
+ };
1995
+
1996
+ jasmine.Spec.prototype.after = function(doAfter) {
1997
+ if (this.queue.isRunning()) {
1998
+ this.queue.add(new jasmine.Block(this.env, doAfter, this));
1999
+ } else {
2000
+ this.afterCallbacks.unshift(doAfter);
2001
+ }
2002
+ };
2003
+
2004
+ jasmine.Spec.prototype.execute = function(onComplete) {
2005
+ var spec = this;
2006
+ if (!spec.env.specFilter(spec)) {
2007
+ spec.results_.skipped = true;
2008
+ spec.finish(onComplete);
2009
+ return;
2010
+ }
2011
+
2012
+ this.env.reporter.reportSpecStarting(this);
2013
+
2014
+ spec.env.currentSpec = spec;
2015
+
2016
+ spec.addBeforesAndAftersToQueue();
2017
+
2018
+ spec.queue.start(function () {
2019
+ spec.finish(onComplete);
2020
+ });
2021
+ };
2022
+
2023
+ jasmine.Spec.prototype.addBeforesAndAftersToQueue = function() {
2024
+ var runner = this.env.currentRunner();
2025
+ var i;
2026
+
2027
+ for (var suite = this.suite; suite; suite = suite.parentSuite) {
2028
+ for (i = 0; i < suite.before_.length; i++) {
2029
+ this.queue.addBefore(new jasmine.Block(this.env, suite.before_[i], this));
2030
+ }
2031
+ }
2032
+ for (i = 0; i < runner.before_.length; i++) {
2033
+ this.queue.addBefore(new jasmine.Block(this.env, runner.before_[i], this));
2034
+ }
2035
+ for (i = 0; i < this.afterCallbacks.length; i++) {
2036
+ this.queue.add(new jasmine.Block(this.env, this.afterCallbacks[i], this));
2037
+ }
2038
+ for (suite = this.suite; suite; suite = suite.parentSuite) {
2039
+ for (i = 0; i < suite.after_.length; i++) {
2040
+ this.queue.add(new jasmine.Block(this.env, suite.after_[i], this));
2041
+ }
2042
+ }
2043
+ for (i = 0; i < runner.after_.length; i++) {
2044
+ this.queue.add(new jasmine.Block(this.env, runner.after_[i], this));
2045
+ }
2046
+ };
2047
+
2048
+ jasmine.Spec.prototype.explodes = function() {
2049
+ throw 'explodes function should not have been called';
2050
+ };
2051
+
2052
+ jasmine.Spec.prototype.spyOn = function(obj, methodName, ignoreMethodDoesntExist) {
2053
+ if (obj == jasmine.undefined) {
2054
+ throw "spyOn could not find an object to spy upon for " + methodName + "()";
2055
+ }
2056
+
2057
+ if (!ignoreMethodDoesntExist && obj[methodName] === jasmine.undefined) {
2058
+ throw methodName + '() method does not exist';
2059
+ }
2060
+
2061
+ if (!ignoreMethodDoesntExist && obj[methodName] && obj[methodName].isSpy) {
2062
+ throw new Error(methodName + ' has already been spied upon');
2063
+ }
2064
+
2065
+ var spyObj = jasmine.createSpy(methodName);
2066
+
2067
+ this.spies_.push(spyObj);
2068
+ spyObj.baseObj = obj;
2069
+ spyObj.methodName = methodName;
2070
+ spyObj.originalValue = obj[methodName];
2071
+
2072
+ obj[methodName] = spyObj;
2073
+
2074
+ return spyObj;
2075
+ };
2076
+
2077
+ jasmine.Spec.prototype.removeAllSpies = function() {
2078
+ for (var i = 0; i < this.spies_.length; i++) {
2079
+ var spy = this.spies_[i];
2080
+ spy.baseObj[spy.methodName] = spy.originalValue;
2081
+ }
2082
+ this.spies_ = [];
2083
+ };
2084
+
2085
+ /**
2086
+ * Internal representation of a Jasmine suite.
2087
+ *
2088
+ * @constructor
2089
+ * @param {jasmine.Env} env
2090
+ * @param {String} description
2091
+ * @param {Function} specDefinitions
2092
+ * @param {jasmine.Suite} parentSuite
2093
+ */
2094
+ jasmine.Suite = function(env, description, specDefinitions, parentSuite) {
2095
+ var self = this;
2096
+ self.id = env.nextSuiteId ? env.nextSuiteId() : null;
2097
+ self.description = description;
2098
+ self.queue = new jasmine.Queue(env);
2099
+ self.parentSuite = parentSuite;
2100
+ self.env = env;
2101
+ self.before_ = [];
2102
+ self.after_ = [];
2103
+ self.children_ = [];
2104
+ self.suites_ = [];
2105
+ self.specs_ = [];
2106
+ };
2107
+
2108
+ jasmine.Suite.prototype.getFullName = function() {
2109
+ var fullName = this.description;
2110
+ for (var parentSuite = this.parentSuite; parentSuite; parentSuite = parentSuite.parentSuite) {
2111
+ fullName = parentSuite.description + ' ' + fullName;
2112
+ }
2113
+ return fullName;
2114
+ };
2115
+
2116
+ jasmine.Suite.prototype.finish = function(onComplete) {
2117
+ this.env.reporter.reportSuiteResults(this);
2118
+ this.finished = true;
2119
+ if (typeof(onComplete) == 'function') {
2120
+ onComplete();
2121
+ }
2122
+ };
2123
+
2124
+ jasmine.Suite.prototype.beforeEach = function(beforeEachFunction) {
2125
+ beforeEachFunction.typeName = 'beforeEach';
2126
+ this.before_.unshift(beforeEachFunction);
2127
+ };
2128
+
2129
+ jasmine.Suite.prototype.afterEach = function(afterEachFunction) {
2130
+ afterEachFunction.typeName = 'afterEach';
2131
+ this.after_.unshift(afterEachFunction);
2132
+ };
2133
+
2134
+ jasmine.Suite.prototype.results = function() {
2135
+ return this.queue.results();
2136
+ };
2137
+
2138
+ jasmine.Suite.prototype.add = function(suiteOrSpec) {
2139
+ this.children_.push(suiteOrSpec);
2140
+ if (suiteOrSpec instanceof jasmine.Suite) {
2141
+ this.suites_.push(suiteOrSpec);
2142
+ this.env.currentRunner().addSuite(suiteOrSpec);
2143
+ } else {
2144
+ this.specs_.push(suiteOrSpec);
2145
+ }
2146
+ this.queue.add(suiteOrSpec);
2147
+ };
2148
+
2149
+ jasmine.Suite.prototype.specs = function() {
2150
+ return this.specs_;
2151
+ };
2152
+
2153
+ jasmine.Suite.prototype.suites = function() {
2154
+ return this.suites_;
2155
+ };
2156
+
2157
+ jasmine.Suite.prototype.children = function() {
2158
+ return this.children_;
2159
+ };
2160
+
2161
+ jasmine.Suite.prototype.execute = function(onComplete) {
2162
+ var self = this;
2163
+ this.queue.start(function () {
2164
+ self.finish(onComplete);
2165
+ });
2166
+ };
2167
+ jasmine.WaitsBlock = function(env, timeout, spec) {
2168
+ this.timeout = timeout;
2169
+ jasmine.Block.call(this, env, null, spec);
2170
+ };
2171
+
2172
+ jasmine.util.inherit(jasmine.WaitsBlock, jasmine.Block);
2173
+
2174
+ jasmine.WaitsBlock.prototype.execute = function (onComplete) {
2175
+ this.env.reporter.log('>> Jasmine waiting for ' + this.timeout + ' ms...');
2176
+ this.env.setTimeout(function () {
2177
+ onComplete();
2178
+ }, this.timeout);
2179
+ };
2180
+ /**
2181
+ * A block which waits for some condition to become true, with timeout.
2182
+ *
2183
+ * @constructor
2184
+ * @extends jasmine.Block
2185
+ * @param {jasmine.Env} env The Jasmine environment.
2186
+ * @param {Number} timeout The maximum time in milliseconds to wait for the condition to become true.
2187
+ * @param {Function} latchFunction A function which returns true when the desired condition has been met.
2188
+ * @param {String} message The message to display if the desired condition hasn't been met within the given time period.
2189
+ * @param {jasmine.Spec} spec The Jasmine spec.
2190
+ */
2191
+ jasmine.WaitsForBlock = function(env, timeout, latchFunction, message, spec) {
2192
+ this.timeout = timeout || env.defaultTimeoutInterval;
2193
+ this.latchFunction = latchFunction;
2194
+ this.message = message;
2195
+ this.totalTimeSpentWaitingForLatch = 0;
2196
+ jasmine.Block.call(this, env, null, spec);
2197
+ };
2198
+ jasmine.util.inherit(jasmine.WaitsForBlock, jasmine.Block);
2199
+
2200
+ jasmine.WaitsForBlock.TIMEOUT_INCREMENT = 10;
2201
+
2202
+ jasmine.WaitsForBlock.prototype.execute = function(onComplete) {
2203
+ this.env.reporter.log('>> Jasmine waiting for ' + (this.message || 'something to happen'));
2204
+ var latchFunctionResult;
2205
+ try {
2206
+ latchFunctionResult = this.latchFunction.apply(this.spec);
2207
+ } catch (e) {
2208
+ this.spec.fail(e);
2209
+ onComplete();
2210
+ return;
2211
+ }
2212
+
2213
+ if (latchFunctionResult) {
2214
+ onComplete();
2215
+ } else if (this.totalTimeSpentWaitingForLatch >= this.timeout) {
2216
+ var message = 'timed out after ' + this.timeout + ' msec waiting for ' + (this.message || 'something to happen');
2217
+ this.spec.fail({
2218
+ name: 'timeout',
2219
+ message: message
2220
+ });
2221
+
2222
+ this.abort = true;
2223
+ onComplete();
2224
+ } else {
2225
+ this.totalTimeSpentWaitingForLatch += jasmine.WaitsForBlock.TIMEOUT_INCREMENT;
2226
+ var self = this;
2227
+ this.env.setTimeout(function() {
2228
+ self.execute(onComplete);
2229
+ }, jasmine.WaitsForBlock.TIMEOUT_INCREMENT);
2230
+ }
2231
+ };
2232
+ // Mock setTimeout, clearTimeout
2233
+ // Contributed by Pivotal Computer Systems, www.pivotalsf.com
2234
+
2235
+ jasmine.FakeTimer = function() {
2236
+ this.reset();
2237
+
2238
+ var self = this;
2239
+ self.setTimeout = function(funcToCall, millis) {
2240
+ self.timeoutsMade++;
2241
+ self.scheduleFunction(self.timeoutsMade, funcToCall, millis, false);
2242
+ return self.timeoutsMade;
2243
+ };
2244
+
2245
+ self.setInterval = function(funcToCall, millis) {
2246
+ self.timeoutsMade++;
2247
+ self.scheduleFunction(self.timeoutsMade, funcToCall, millis, true);
2248
+ return self.timeoutsMade;
2249
+ };
2250
+
2251
+ self.clearTimeout = function(timeoutKey) {
2252
+ self.scheduledFunctions[timeoutKey] = jasmine.undefined;
2253
+ };
2254
+
2255
+ self.clearInterval = function(timeoutKey) {
2256
+ self.scheduledFunctions[timeoutKey] = jasmine.undefined;
2257
+ };
2258
+
2259
+ };
2260
+
2261
+ jasmine.FakeTimer.prototype.reset = function() {
2262
+ this.timeoutsMade = 0;
2263
+ this.scheduledFunctions = {};
2264
+ this.nowMillis = 0;
2265
+ };
2266
+
2267
+ jasmine.FakeTimer.prototype.tick = function(millis) {
2268
+ var oldMillis = this.nowMillis;
2269
+ var newMillis = oldMillis + millis;
2270
+ this.runFunctionsWithinRange(oldMillis, newMillis);
2271
+ this.nowMillis = newMillis;
2272
+ };
2273
+
2274
+ jasmine.FakeTimer.prototype.runFunctionsWithinRange = function(oldMillis, nowMillis) {
2275
+ var scheduledFunc;
2276
+ var funcsToRun = [];
2277
+ for (var timeoutKey in this.scheduledFunctions) {
2278
+ scheduledFunc = this.scheduledFunctions[timeoutKey];
2279
+ if (scheduledFunc != jasmine.undefined &&
2280
+ scheduledFunc.runAtMillis >= oldMillis &&
2281
+ scheduledFunc.runAtMillis <= nowMillis) {
2282
+ funcsToRun.push(scheduledFunc);
2283
+ this.scheduledFunctions[timeoutKey] = jasmine.undefined;
2284
+ }
2285
+ }
2286
+
2287
+ if (funcsToRun.length > 0) {
2288
+ funcsToRun.sort(function(a, b) {
2289
+ return a.runAtMillis - b.runAtMillis;
2290
+ });
2291
+ for (var i = 0; i < funcsToRun.length; ++i) {
2292
+ try {
2293
+ var funcToRun = funcsToRun[i];
2294
+ this.nowMillis = funcToRun.runAtMillis;
2295
+ funcToRun.funcToCall();
2296
+ if (funcToRun.recurring) {
2297
+ this.scheduleFunction(funcToRun.timeoutKey,
2298
+ funcToRun.funcToCall,
2299
+ funcToRun.millis,
2300
+ true);
2301
+ }
2302
+ } catch(e) {
2303
+ }
2304
+ }
2305
+ this.runFunctionsWithinRange(oldMillis, nowMillis);
2306
+ }
2307
+ };
2308
+
2309
+ jasmine.FakeTimer.prototype.scheduleFunction = function(timeoutKey, funcToCall, millis, recurring) {
2310
+ this.scheduledFunctions[timeoutKey] = {
2311
+ runAtMillis: this.nowMillis + millis,
2312
+ funcToCall: funcToCall,
2313
+ recurring: recurring,
2314
+ timeoutKey: timeoutKey,
2315
+ millis: millis
2316
+ };
2317
+ };
2318
+
2319
+ /**
2320
+ * @namespace
2321
+ */
2322
+ jasmine.Clock = {
2323
+ defaultFakeTimer: new jasmine.FakeTimer(),
2324
+
2325
+ reset: function() {
2326
+ jasmine.Clock.assertInstalled();
2327
+ jasmine.Clock.defaultFakeTimer.reset();
2328
+ },
2329
+
2330
+ tick: function(millis) {
2331
+ jasmine.Clock.assertInstalled();
2332
+ jasmine.Clock.defaultFakeTimer.tick(millis);
2333
+ },
2334
+
2335
+ runFunctionsWithinRange: function(oldMillis, nowMillis) {
2336
+ jasmine.Clock.defaultFakeTimer.runFunctionsWithinRange(oldMillis, nowMillis);
2337
+ },
2338
+
2339
+ scheduleFunction: function(timeoutKey, funcToCall, millis, recurring) {
2340
+ jasmine.Clock.defaultFakeTimer.scheduleFunction(timeoutKey, funcToCall, millis, recurring);
2341
+ },
2342
+
2343
+ useMock: function() {
2344
+ if (!jasmine.Clock.isInstalled()) {
2345
+ var spec = jasmine.getEnv().currentSpec;
2346
+ spec.after(jasmine.Clock.uninstallMock);
2347
+
2348
+ jasmine.Clock.installMock();
2349
+ }
2350
+ },
2351
+
2352
+ installMock: function() {
2353
+ jasmine.Clock.installed = jasmine.Clock.defaultFakeTimer;
2354
+ },
2355
+
2356
+ uninstallMock: function() {
2357
+ jasmine.Clock.assertInstalled();
2358
+ jasmine.Clock.installed = jasmine.Clock.real;
2359
+ },
2360
+
2361
+ real: {
2362
+ setTimeout: jasmine.getGlobal().setTimeout,
2363
+ clearTimeout: jasmine.getGlobal().clearTimeout,
2364
+ setInterval: jasmine.getGlobal().setInterval,
2365
+ clearInterval: jasmine.getGlobal().clearInterval
2366
+ },
2367
+
2368
+ assertInstalled: function() {
2369
+ if (!jasmine.Clock.isInstalled()) {
2370
+ throw new Error("Mock clock is not installed, use jasmine.Clock.useMock()");
2371
+ }
2372
+ },
2373
+
2374
+ isInstalled: function() {
2375
+ return jasmine.Clock.installed == jasmine.Clock.defaultFakeTimer;
2376
+ },
2377
+
2378
+ installed: null
2379
+ };
2380
+ jasmine.Clock.installed = jasmine.Clock.real;
2381
+
2382
+ //else for IE support
2383
+ jasmine.getGlobal().setTimeout = function(funcToCall, millis) {
2384
+ if (jasmine.Clock.installed.setTimeout.apply) {
2385
+ return jasmine.Clock.installed.setTimeout.apply(this, arguments);
2386
+ } else {
2387
+ return jasmine.Clock.installed.setTimeout(funcToCall, millis);
2388
+ }
2389
+ };
2390
+
2391
+ jasmine.getGlobal().setInterval = function(funcToCall, millis) {
2392
+ if (jasmine.Clock.installed.setInterval.apply) {
2393
+ return jasmine.Clock.installed.setInterval.apply(this, arguments);
2394
+ } else {
2395
+ return jasmine.Clock.installed.setInterval(funcToCall, millis);
2396
+ }
2397
+ };
2398
+
2399
+ jasmine.getGlobal().clearTimeout = function(timeoutKey) {
2400
+ if (jasmine.Clock.installed.clearTimeout.apply) {
2401
+ return jasmine.Clock.installed.clearTimeout.apply(this, arguments);
2402
+ } else {
2403
+ return jasmine.Clock.installed.clearTimeout(timeoutKey);
2404
+ }
2405
+ };
2406
+
2407
+ jasmine.getGlobal().clearInterval = function(timeoutKey) {
2408
+ if (jasmine.Clock.installed.clearTimeout.apply) {
2409
+ return jasmine.Clock.installed.clearInterval.apply(this, arguments);
2410
+ } else {
2411
+ return jasmine.Clock.installed.clearInterval(timeoutKey);
2412
+ }
2413
+ };
2414
+
2415
+
2416
+ jasmine.version_= {
2417
+ "major": 1,
2418
+ "minor": 0,
2419
+ "build": 1,
2420
+ "revision": 1286311016
2421
+ };