deckrb 0.1.1 → 0.2.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (78) hide show
  1. data/README.md +84 -25
  2. data/bin/deck +3 -4
  3. data/lib/deck/rack_app.rb +39 -7
  4. data/lib/deck/slide.rb +9 -2
  5. data/lib/deck/slide_deck.rb +10 -13
  6. data/lib/deck/version.rb +1 -1
  7. data/public/coderay.css +84 -0
  8. data/public/deck.js/GPL-license.txt +278 -0
  9. data/public/deck.js/MIT-license.txt +21 -0
  10. data/public/deck.js/README.md +57 -0
  11. data/public/deck.js/core/deck.core.css +404 -0
  12. data/public/deck.js/core/deck.core.html +39 -0
  13. data/public/deck.js/core/deck.core.js +498 -0
  14. data/public/deck.js/core/deck.core.scss +447 -0
  15. data/public/deck.js/extensions/goto/deck.goto.css +41 -0
  16. data/public/deck.js/extensions/goto/deck.goto.html +7 -0
  17. data/public/deck.js/extensions/goto/deck.goto.js +134 -0
  18. data/public/deck.js/extensions/goto/deck.goto.scss +46 -0
  19. data/public/deck.js/extensions/hash/deck.hash.css +13 -0
  20. data/public/deck.js/extensions/hash/deck.hash.html +2 -0
  21. data/public/deck.js/extensions/hash/deck.hash.js +129 -0
  22. data/public/deck.js/extensions/hash/deck.hash.scss +15 -0
  23. data/public/deck.js/extensions/menu/deck.menu.css +47 -0
  24. data/public/deck.js/extensions/menu/deck.menu.js +187 -0
  25. data/public/deck.js/extensions/menu/deck.menu.scss +58 -0
  26. data/public/deck.js/extensions/navigation/deck.navigation.css +43 -0
  27. data/public/deck.js/extensions/navigation/deck.navigation.html +3 -0
  28. data/public/deck.js/extensions/navigation/deck.navigation.js +91 -0
  29. data/public/deck.js/extensions/navigation/deck.navigation.scss +56 -0
  30. data/public/deck.js/extensions/scale/deck.scale.css +16 -0
  31. data/public/deck.js/extensions/scale/deck.scale.js +156 -0
  32. data/public/deck.js/extensions/scale/deck.scale.scss +17 -0
  33. data/public/deck.js/extensions/status/deck.status.css +18 -0
  34. data/public/deck.js/extensions/status/deck.status.html +6 -0
  35. data/public/deck.js/extensions/status/deck.status.js +95 -0
  36. data/public/deck.js/extensions/status/deck.status.scss +22 -0
  37. data/public/deck.js/extensions/theme-picker/deck.theme-picker.css +55 -0
  38. data/public/deck.js/extensions/theme-picker/deck.theme-picker.js +13 -0
  39. data/public/deck.js/introduction/index.html +221 -0
  40. data/public/deck.js/introduction/index.rb +101 -0
  41. data/public/deck.js/jquery-1.7.min.js +4 -0
  42. data/public/deck.js/modernizr.custom.js +4 -0
  43. data/public/deck.js/test/fixtures/complex.html +24 -0
  44. data/public/deck.js/test/fixtures/empty.html +19 -0
  45. data/public/deck.js/test/fixtures/iframe_simple.html +10 -0
  46. data/public/deck.js/test/fixtures/iframes.html +32 -0
  47. data/public/deck.js/test/fixtures/nesteds.html +36 -0
  48. data/public/deck.js/test/fixtures/standard.html +42 -0
  49. data/public/deck.js/test/index.html +39 -0
  50. data/public/deck.js/test/lib/jasmine-html.js +190 -0
  51. data/public/deck.js/test/lib/jasmine-jquery.js +288 -0
  52. data/public/deck.js/test/lib/jasmine.css +166 -0
  53. data/public/deck.js/test/lib/jasmine.js +2477 -0
  54. data/public/deck.js/test/settings.js +3 -0
  55. data/public/deck.js/test/spec.core.js +434 -0
  56. data/public/deck.js/test/spec.goto.js +119 -0
  57. data/public/deck.js/test/spec.hash.js +81 -0
  58. data/public/deck.js/test/spec.menu.js +66 -0
  59. data/public/deck.js/test/spec.navigation.js +51 -0
  60. data/public/deck.js/test/spec.scale.js +57 -0
  61. data/public/deck.js/test/spec.status.js +58 -0
  62. data/public/deck.js/themes/style/neon.css +114 -0
  63. data/public/deck.js/themes/style/neon.scss +139 -0
  64. data/public/deck.js/themes/style/swiss.css +75 -0
  65. data/public/deck.js/themes/style/swiss.scss +91 -0
  66. data/public/deck.js/themes/style/web-2.0.css +205 -0
  67. data/public/deck.js/themes/style/web-2.0.scss +236 -0
  68. data/public/deck.js/themes/transition/fade.css +44 -0
  69. data/public/deck.js/themes/transition/fade.scss +70 -0
  70. data/public/deck.js/themes/transition/horizontal-slide.css +79 -0
  71. data/public/deck.js/themes/transition/horizontal-slide.scss +94 -0
  72. data/public/deck.js/themes/transition/vertical-slide.css +97 -0
  73. data/public/deck.js/themes/transition/vertical-slide.scss +116 -0
  74. data/public/favicon.ico +0 -0
  75. data/spec/rack_app_spec.rb +101 -33
  76. data/spec/slide_deck_spec.rb +6 -7
  77. data/spec/slide_spec.rb +19 -0
  78. metadata +95 -16
@@ -0,0 +1,166 @@
1
+ body {
2
+ font-family: "Helvetica Neue Light", "Lucida Grande", "Calibri", "Arial", sans-serif;
3
+ }
4
+
5
+
6
+ .jasmine_reporter a:visited, .jasmine_reporter a {
7
+ color: #303;
8
+ }
9
+
10
+ .jasmine_reporter a:hover, .jasmine_reporter a:active {
11
+ color: blue;
12
+ }
13
+
14
+ .run_spec {
15
+ float:right;
16
+ padding-right: 5px;
17
+ font-size: .8em;
18
+ text-decoration: none;
19
+ }
20
+
21
+ .jasmine_reporter {
22
+ margin: 0 5px;
23
+ }
24
+
25
+ .banner {
26
+ color: #303;
27
+ background-color: #fef;
28
+ padding: 5px;
29
+ }
30
+
31
+ .logo {
32
+ float: left;
33
+ font-size: 1.1em;
34
+ padding-left: 5px;
35
+ }
36
+
37
+ .logo .version {
38
+ font-size: .6em;
39
+ padding-left: 1em;
40
+ }
41
+
42
+ .runner.running {
43
+ background-color: yellow;
44
+ }
45
+
46
+
47
+ .options {
48
+ text-align: right;
49
+ font-size: .8em;
50
+ }
51
+
52
+
53
+
54
+
55
+ .suite {
56
+ border: 1px outset gray;
57
+ margin: 5px 0;
58
+ padding-left: 1em;
59
+ }
60
+
61
+ .suite .suite {
62
+ margin: 5px;
63
+ }
64
+
65
+ .suite.passed {
66
+ background-color: #dfd;
67
+ }
68
+
69
+ .suite.failed {
70
+ background-color: #fdd;
71
+ }
72
+
73
+ .spec {
74
+ margin: 5px;
75
+ padding-left: 1em;
76
+ clear: both;
77
+ }
78
+
79
+ .spec.failed, .spec.passed, .spec.skipped {
80
+ padding-bottom: 5px;
81
+ border: 1px solid gray;
82
+ }
83
+
84
+ .spec.failed {
85
+ background-color: #fbb;
86
+ border-color: red;
87
+ }
88
+
89
+ .spec.passed {
90
+ background-color: #bfb;
91
+ border-color: green;
92
+ }
93
+
94
+ .spec.skipped {
95
+ background-color: #bbb;
96
+ }
97
+
98
+ .messages {
99
+ border-left: 1px dashed gray;
100
+ padding-left: 1em;
101
+ padding-right: 1em;
102
+ }
103
+
104
+ .passed {
105
+ background-color: #cfc;
106
+ display: none;
107
+ }
108
+
109
+ .failed {
110
+ background-color: #fbb;
111
+ }
112
+
113
+ .skipped {
114
+ color: #777;
115
+ background-color: #eee;
116
+ display: none;
117
+ }
118
+
119
+
120
+ /*.resultMessage {*/
121
+ /*white-space: pre;*/
122
+ /*}*/
123
+
124
+ .resultMessage span.result {
125
+ display: block;
126
+ line-height: 2em;
127
+ color: black;
128
+ }
129
+
130
+ .resultMessage .mismatch {
131
+ color: black;
132
+ }
133
+
134
+ .stackTrace {
135
+ white-space: pre;
136
+ font-size: .8em;
137
+ margin-left: 10px;
138
+ max-height: 5em;
139
+ overflow: auto;
140
+ border: 1px inset red;
141
+ padding: 1em;
142
+ background: #eef;
143
+ }
144
+
145
+ .finished-at {
146
+ padding-left: 1em;
147
+ font-size: .6em;
148
+ }
149
+
150
+ .show-passed .passed,
151
+ .show-skipped .skipped {
152
+ display: block;
153
+ }
154
+
155
+
156
+ #jasmine_content {
157
+ position:fixed;
158
+ right: 100%;
159
+ }
160
+
161
+ .runner {
162
+ border: 1px solid gray;
163
+ display: block;
164
+ margin: 5px 0;
165
+ padding: 2px 0 2px 10px;
166
+ }
@@ -0,0 +1,2477 @@
1
+ var isCommonJS = typeof window == "undefined";
2
+
3
+ /**
4
+ * Top level namespace for Jasmine, a lightweight JavaScript BDD/spec/testing framework.
5
+ *
6
+ * @namespace
7
+ */
8
+ var jasmine = {};
9
+ if (isCommonJS) exports.jasmine = jasmine;
10
+ /**
11
+ * @private
12
+ */
13
+ jasmine.unimplementedMethod_ = function() {
14
+ throw new Error("unimplemented method");
15
+ };
16
+
17
+ /**
18
+ * Use <code>jasmine.undefined</code> instead of <code>undefined</code>, since <code>undefined</code> is just
19
+ * a plain old variable and may be redefined by somebody else.
20
+ *
21
+ * @private
22
+ */
23
+ jasmine.undefined = jasmine.___undefined___;
24
+
25
+ /**
26
+ * Show diagnostic messages in the console if set to true
27
+ *
28
+ */
29
+ jasmine.VERBOSE = false;
30
+
31
+ /**
32
+ * 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.
33
+ *
34
+ */
35
+ jasmine.DEFAULT_UPDATE_INTERVAL = 250;
36
+
37
+ /**
38
+ * Default timeout interval in milliseconds for waitsFor() blocks.
39
+ */
40
+ jasmine.DEFAULT_TIMEOUT_INTERVAL = 5000;
41
+
42
+ jasmine.getGlobal = function() {
43
+ function getGlobal() {
44
+ return this;
45
+ }
46
+
47
+ return getGlobal();
48
+ };
49
+
50
+ /**
51
+ * Allows for bound functions to be compared. Internal use only.
52
+ *
53
+ * @ignore
54
+ * @private
55
+ * @param base {Object} bound 'this' for the function
56
+ * @param name {Function} function to find
57
+ */
58
+ jasmine.bindOriginal_ = function(base, name) {
59
+ var original = base[name];
60
+ if (original.apply) {
61
+ return function() {
62
+ return original.apply(base, arguments);
63
+ };
64
+ } else {
65
+ // IE support
66
+ return jasmine.getGlobal()[name];
67
+ }
68
+ };
69
+
70
+ jasmine.setTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'setTimeout');
71
+ jasmine.clearTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearTimeout');
72
+ jasmine.setInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'setInterval');
73
+ jasmine.clearInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearInterval');
74
+
75
+ jasmine.MessageResult = function(values) {
76
+ this.type = 'log';
77
+ this.values = values;
78
+ this.trace = new Error(); // todo: test better
79
+ };
80
+
81
+ jasmine.MessageResult.prototype.toString = function() {
82
+ var text = "";
83
+ for (var i = 0; i < this.values.length; i++) {
84
+ if (i > 0) text += " ";
85
+ if (jasmine.isString_(this.values[i])) {
86
+ text += this.values[i];
87
+ } else {
88
+ text += jasmine.pp(this.values[i]);
89
+ }
90
+ }
91
+ return text;
92
+ };
93
+
94
+ jasmine.ExpectationResult = function(params) {
95
+ this.type = 'expect';
96
+ this.matcherName = params.matcherName;
97
+ this.passed_ = params.passed;
98
+ this.expected = params.expected;
99
+ this.actual = params.actual;
100
+ this.message = this.passed_ ? 'Passed.' : params.message;
101
+
102
+ var trace = (params.trace || new Error(this.message));
103
+ this.trace = this.passed_ ? '' : trace;
104
+ };
105
+
106
+ jasmine.ExpectationResult.prototype.toString = function () {
107
+ return this.message;
108
+ };
109
+
110
+ jasmine.ExpectationResult.prototype.passed = function () {
111
+ return this.passed_;
112
+ };
113
+
114
+ /**
115
+ * Getter for the Jasmine environment. Ensures one gets created
116
+ */
117
+ jasmine.getEnv = function() {
118
+ var env = jasmine.currentEnv_ = jasmine.currentEnv_ || new jasmine.Env();
119
+ return env;
120
+ };
121
+
122
+ /**
123
+ * @ignore
124
+ * @private
125
+ * @param value
126
+ * @returns {Boolean}
127
+ */
128
+ jasmine.isArray_ = function(value) {
129
+ return jasmine.isA_("Array", value);
130
+ };
131
+
132
+ /**
133
+ * @ignore
134
+ * @private
135
+ * @param value
136
+ * @returns {Boolean}
137
+ */
138
+ jasmine.isString_ = function(value) {
139
+ return jasmine.isA_("String", value);
140
+ };
141
+
142
+ /**
143
+ * @ignore
144
+ * @private
145
+ * @param value
146
+ * @returns {Boolean}
147
+ */
148
+ jasmine.isNumber_ = function(value) {
149
+ return jasmine.isA_("Number", value);
150
+ };
151
+
152
+ /**
153
+ * @ignore
154
+ * @private
155
+ * @param {String} typeName
156
+ * @param value
157
+ * @returns {Boolean}
158
+ */
159
+ jasmine.isA_ = function(typeName, value) {
160
+ return Object.prototype.toString.apply(value) === '[object ' + typeName + ']';
161
+ };
162
+
163
+ /**
164
+ * Pretty printer for expecations. Takes any object and turns it into a human-readable string.
165
+ *
166
+ * @param value {Object} an object to be outputted
167
+ * @returns {String}
168
+ */
169
+ jasmine.pp = function(value) {
170
+ var stringPrettyPrinter = new jasmine.StringPrettyPrinter();
171
+ stringPrettyPrinter.format(value);
172
+ return stringPrettyPrinter.string;
173
+ };
174
+
175
+ /**
176
+ * Returns true if the object is a DOM Node.
177
+ *
178
+ * @param {Object} obj object to check
179
+ * @returns {Boolean}
180
+ */
181
+ jasmine.isDomNode = function(obj) {
182
+ return obj.nodeType > 0;
183
+ };
184
+
185
+ /**
186
+ * Returns a matchable 'generic' object of the class type. For use in expecations of type when values don't matter.
187
+ *
188
+ * @example
189
+ * // don't care about which function is passed in, as long as it's a function
190
+ * expect(mySpy).toHaveBeenCalledWith(jasmine.any(Function));
191
+ *
192
+ * @param {Class} clazz
193
+ * @returns matchable object of the type clazz
194
+ */
195
+ jasmine.any = function(clazz) {
196
+ return new jasmine.Matchers.Any(clazz);
197
+ };
198
+
199
+ /**
200
+ * Jasmine Spies are test doubles that can act as stubs, spies, fakes or when used in an expecation, mocks.
201
+ *
202
+ * Spies should be created in test setup, before expectations. They can then be checked, using the standard Jasmine
203
+ * expectation syntax. Spies can be checked if they were called or not and what the calling params were.
204
+ *
205
+ * A Spy has the following fields: wasCalled, callCount, mostRecentCall, and argsForCall (see docs).
206
+ *
207
+ * Spies are torn down at the end of every spec.
208
+ *
209
+ * Note: Do <b>not</b> call new jasmine.Spy() directly - a spy must be created using spyOn, jasmine.createSpy or jasmine.createSpyObj.
210
+ *
211
+ * @example
212
+ * // a stub
213
+ * var myStub = jasmine.createSpy('myStub'); // can be used anywhere
214
+ *
215
+ * // spy example
216
+ * var foo = {
217
+ * not: function(bool) { return !bool; }
218
+ * }
219
+ *
220
+ * // actual foo.not will not be called, execution stops
221
+ * spyOn(foo, 'not');
222
+
223
+ // foo.not spied upon, execution will continue to implementation
224
+ * spyOn(foo, 'not').andCallThrough();
225
+ *
226
+ * // fake example
227
+ * var foo = {
228
+ * not: function(bool) { return !bool; }
229
+ * }
230
+ *
231
+ * // foo.not(val) will return val
232
+ * spyOn(foo, 'not').andCallFake(function(value) {return value;});
233
+ *
234
+ * // mock example
235
+ * foo.not(7 == 7);
236
+ * expect(foo.not).toHaveBeenCalled();
237
+ * expect(foo.not).toHaveBeenCalledWith(true);
238
+ *
239
+ * @constructor
240
+ * @see spyOn, jasmine.createSpy, jasmine.createSpyObj
241
+ * @param {String} name
242
+ */
243
+ jasmine.Spy = function(name) {
244
+ /**
245
+ * The name of the spy, if provided.
246
+ */
247
+ this.identity = name || 'unknown';
248
+ /**
249
+ * Is this Object a spy?
250
+ */
251
+ this.isSpy = true;
252
+ /**
253
+ * The actual function this spy stubs.
254
+ */
255
+ this.plan = function() {
256
+ };
257
+ /**
258
+ * Tracking of the most recent call to the spy.
259
+ * @example
260
+ * var mySpy = jasmine.createSpy('foo');
261
+ * mySpy(1, 2);
262
+ * mySpy.mostRecentCall.args = [1, 2];
263
+ */
264
+ this.mostRecentCall = {};
265
+
266
+ /**
267
+ * Holds arguments for each call to the spy, indexed by call count
268
+ * @example
269
+ * var mySpy = jasmine.createSpy('foo');
270
+ * mySpy(1, 2);
271
+ * mySpy(7, 8);
272
+ * mySpy.mostRecentCall.args = [7, 8];
273
+ * mySpy.argsForCall[0] = [1, 2];
274
+ * mySpy.argsForCall[1] = [7, 8];
275
+ */
276
+ this.argsForCall = [];
277
+ this.calls = [];
278
+ };
279
+
280
+ /**
281
+ * Tells a spy to call through to the actual implemenatation.
282
+ *
283
+ * @example
284
+ * var foo = {
285
+ * bar: function() { // do some stuff }
286
+ * }
287
+ *
288
+ * // defining a spy on an existing property: foo.bar
289
+ * spyOn(foo, 'bar').andCallThrough();
290
+ */
291
+ jasmine.Spy.prototype.andCallThrough = function() {
292
+ this.plan = this.originalValue;
293
+ return this;
294
+ };
295
+
296
+ /**
297
+ * For setting the return value of a spy.
298
+ *
299
+ * @example
300
+ * // defining a spy from scratch: foo() returns 'baz'
301
+ * var foo = jasmine.createSpy('spy on foo').andReturn('baz');
302
+ *
303
+ * // defining a spy on an existing property: foo.bar() returns 'baz'
304
+ * spyOn(foo, 'bar').andReturn('baz');
305
+ *
306
+ * @param {Object} value
307
+ */
308
+ jasmine.Spy.prototype.andReturn = function(value) {
309
+ this.plan = function() {
310
+ return value;
311
+ };
312
+ return this;
313
+ };
314
+
315
+ /**
316
+ * For throwing an exception when a spy is called.
317
+ *
318
+ * @example
319
+ * // defining a spy from scratch: foo() throws an exception w/ message 'ouch'
320
+ * var foo = jasmine.createSpy('spy on foo').andThrow('baz');
321
+ *
322
+ * // defining a spy on an existing property: foo.bar() throws an exception w/ message 'ouch'
323
+ * spyOn(foo, 'bar').andThrow('baz');
324
+ *
325
+ * @param {String} exceptionMsg
326
+ */
327
+ jasmine.Spy.prototype.andThrow = function(exceptionMsg) {
328
+ this.plan = function() {
329
+ throw exceptionMsg;
330
+ };
331
+ return this;
332
+ };
333
+
334
+ /**
335
+ * Calls an alternate implementation when a spy is called.
336
+ *
337
+ * @example
338
+ * var baz = function() {
339
+ * // do some stuff, return something
340
+ * }
341
+ * // defining a spy from scratch: foo() calls the function baz
342
+ * var foo = jasmine.createSpy('spy on foo').andCall(baz);
343
+ *
344
+ * // defining a spy on an existing property: foo.bar() calls an anonymnous function
345
+ * spyOn(foo, 'bar').andCall(function() { return 'baz';} );
346
+ *
347
+ * @param {Function} fakeFunc
348
+ */
349
+ jasmine.Spy.prototype.andCallFake = function(fakeFunc) {
350
+ this.plan = fakeFunc;
351
+ return this;
352
+ };
353
+
354
+ /**
355
+ * Resets all of a spy's the tracking variables so that it can be used again.
356
+ *
357
+ * @example
358
+ * spyOn(foo, 'bar');
359
+ *
360
+ * foo.bar();
361
+ *
362
+ * expect(foo.bar.callCount).toEqual(1);
363
+ *
364
+ * foo.bar.reset();
365
+ *
366
+ * expect(foo.bar.callCount).toEqual(0);
367
+ */
368
+ jasmine.Spy.prototype.reset = function() {
369
+ this.wasCalled = false;
370
+ this.callCount = 0;
371
+ this.argsForCall = [];
372
+ this.calls = [];
373
+ this.mostRecentCall = {};
374
+ };
375
+
376
+ jasmine.createSpy = function(name) {
377
+
378
+ var spyObj = function() {
379
+ spyObj.wasCalled = true;
380
+ spyObj.callCount++;
381
+ var args = jasmine.util.argsToArray(arguments);
382
+ spyObj.mostRecentCall.object = this;
383
+ spyObj.mostRecentCall.args = args;
384
+ spyObj.argsForCall.push(args);
385
+ spyObj.calls.push({object: this, args: args});
386
+ return spyObj.plan.apply(this, arguments);
387
+ };
388
+
389
+ var spy = new jasmine.Spy(name);
390
+
391
+ for (var prop in spy) {
392
+ spyObj[prop] = spy[prop];
393
+ }
394
+
395
+ spyObj.reset();
396
+
397
+ return spyObj;
398
+ };
399
+
400
+ /**
401
+ * Determines whether an object is a spy.
402
+ *
403
+ * @param {jasmine.Spy|Object} putativeSpy
404
+ * @returns {Boolean}
405
+ */
406
+ jasmine.isSpy = function(putativeSpy) {
407
+ return putativeSpy && putativeSpy.isSpy;
408
+ };
409
+
410
+ /**
411
+ * Creates a more complicated spy: an Object that has every property a function that is a spy. Used for stubbing something
412
+ * large in one call.
413
+ *
414
+ * @param {String} baseName name of spy class
415
+ * @param {Array} methodNames array of names of methods to make spies
416
+ */
417
+ jasmine.createSpyObj = function(baseName, methodNames) {
418
+ if (!jasmine.isArray_(methodNames) || methodNames.length === 0) {
419
+ throw new Error('createSpyObj requires a non-empty array of method names to create spies for');
420
+ }
421
+ var obj = {};
422
+ for (var i = 0; i < methodNames.length; i++) {
423
+ obj[methodNames[i]] = jasmine.createSpy(baseName + '.' + methodNames[i]);
424
+ }
425
+ return obj;
426
+ };
427
+
428
+ /**
429
+ * All parameters are pretty-printed and concatenated together, then written to the current spec's output.
430
+ *
431
+ * Be careful not to leave calls to <code>jasmine.log</code> in production code.
432
+ */
433
+ jasmine.log = function() {
434
+ var spec = jasmine.getEnv().currentSpec;
435
+ spec.log.apply(spec, arguments);
436
+ };
437
+
438
+ /**
439
+ * Function that installs a spy on an existing object's method name. Used within a Spec to create a spy.
440
+ *
441
+ * @example
442
+ * // spy example
443
+ * var foo = {
444
+ * not: function(bool) { return !bool; }
445
+ * }
446
+ * spyOn(foo, 'not'); // actual foo.not will not be called, execution stops
447
+ *
448
+ * @see jasmine.createSpy
449
+ * @param obj
450
+ * @param methodName
451
+ * @returns a Jasmine spy that can be chained with all spy methods
452
+ */
453
+ var spyOn = function(obj, methodName) {
454
+ return jasmine.getEnv().currentSpec.spyOn(obj, methodName);
455
+ };
456
+ if (isCommonJS) exports.spyOn = spyOn;
457
+
458
+ /**
459
+ * Creates a Jasmine spec that will be added to the current suite.
460
+ *
461
+ * // TODO: pending tests
462
+ *
463
+ * @example
464
+ * it('should be true', function() {
465
+ * expect(true).toEqual(true);
466
+ * });
467
+ *
468
+ * @param {String} desc description of this specification
469
+ * @param {Function} func defines the preconditions and expectations of the spec
470
+ */
471
+ var it = function(desc, func) {
472
+ return jasmine.getEnv().it(desc, func);
473
+ };
474
+ if (isCommonJS) exports.it = it;
475
+
476
+ /**
477
+ * Creates a <em>disabled</em> Jasmine spec.
478
+ *
479
+ * A convenience method that allows existing specs to be disabled temporarily during development.
480
+ *
481
+ * @param {String} desc description of this specification
482
+ * @param {Function} func defines the preconditions and expectations of the spec
483
+ */
484
+ var xit = function(desc, func) {
485
+ return jasmine.getEnv().xit(desc, func);
486
+ };
487
+ if (isCommonJS) exports.xit = xit;
488
+
489
+ /**
490
+ * Starts a chain for a Jasmine expectation.
491
+ *
492
+ * It is passed an Object that is the actual value and should chain to one of the many
493
+ * jasmine.Matchers functions.
494
+ *
495
+ * @param {Object} actual Actual value to test against and expected value
496
+ */
497
+ var expect = function(actual) {
498
+ return jasmine.getEnv().currentSpec.expect(actual);
499
+ };
500
+ if (isCommonJS) exports.expect = expect;
501
+
502
+ /**
503
+ * Defines part of a jasmine spec. Used in cominbination with waits or waitsFor in asynchrnous specs.
504
+ *
505
+ * @param {Function} func Function that defines part of a jasmine spec.
506
+ */
507
+ var runs = function(func) {
508
+ jasmine.getEnv().currentSpec.runs(func);
509
+ };
510
+ if (isCommonJS) exports.runs = runs;
511
+
512
+ /**
513
+ * Waits a fixed time period before moving to the next block.
514
+ *
515
+ * @deprecated Use waitsFor() instead
516
+ * @param {Number} timeout milliseconds to wait
517
+ */
518
+ var waits = function(timeout) {
519
+ jasmine.getEnv().currentSpec.waits(timeout);
520
+ };
521
+ if (isCommonJS) exports.waits = waits;
522
+
523
+ /**
524
+ * Waits for the latchFunction to return true before proceeding to the next block.
525
+ *
526
+ * @param {Function} latchFunction
527
+ * @param {String} optional_timeoutMessage
528
+ * @param {Number} optional_timeout
529
+ */
530
+ var waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) {
531
+ jasmine.getEnv().currentSpec.waitsFor.apply(jasmine.getEnv().currentSpec, arguments);
532
+ };
533
+ if (isCommonJS) exports.waitsFor = waitsFor;
534
+
535
+ /**
536
+ * A function that is called before each spec in a suite.
537
+ *
538
+ * Used for spec setup, including validating assumptions.
539
+ *
540
+ * @param {Function} beforeEachFunction
541
+ */
542
+ var beforeEach = function(beforeEachFunction) {
543
+ jasmine.getEnv().beforeEach(beforeEachFunction);
544
+ };
545
+ if (isCommonJS) exports.beforeEach = beforeEach;
546
+
547
+ /**
548
+ * A function that is called after each spec in a suite.
549
+ *
550
+ * Used for restoring any state that is hijacked during spec execution.
551
+ *
552
+ * @param {Function} afterEachFunction
553
+ */
554
+ var afterEach = function(afterEachFunction) {
555
+ jasmine.getEnv().afterEach(afterEachFunction);
556
+ };
557
+ if (isCommonJS) exports.afterEach = afterEach;
558
+
559
+ /**
560
+ * Defines a suite of specifications.
561
+ *
562
+ * Stores the description and all defined specs in the Jasmine environment as one suite of specs. Variables declared
563
+ * are accessible by calls to beforeEach, it, and afterEach. Describe blocks can be nested, allowing for specialization
564
+ * of setup in some tests.
565
+ *
566
+ * @example
567
+ * // TODO: a simple suite
568
+ *
569
+ * // TODO: a simple suite with a nested describe block
570
+ *
571
+ * @param {String} description A string, usually the class under test.
572
+ * @param {Function} specDefinitions function that defines several specs.
573
+ */
574
+ var describe = function(description, specDefinitions) {
575
+ return jasmine.getEnv().describe(description, specDefinitions);
576
+ };
577
+ if (isCommonJS) exports.describe = describe;
578
+
579
+ /**
580
+ * Disables a suite of specifications. Used to disable some suites in a file, or files, temporarily during development.
581
+ *
582
+ * @param {String} description A string, usually the class under test.
583
+ * @param {Function} specDefinitions function that defines several specs.
584
+ */
585
+ var xdescribe = function(description, specDefinitions) {
586
+ return jasmine.getEnv().xdescribe(description, specDefinitions);
587
+ };
588
+ if (isCommonJS) exports.xdescribe = xdescribe;
589
+
590
+
591
+ // Provide the XMLHttpRequest class for IE 5.x-6.x:
592
+ jasmine.XmlHttpRequest = (typeof XMLHttpRequest == "undefined") ? function() {
593
+ function tryIt(f) {
594
+ try {
595
+ return f();
596
+ } catch(e) {
597
+ }
598
+ return null;
599
+ }
600
+
601
+ var xhr = tryIt(function() {
602
+ return new ActiveXObject("Msxml2.XMLHTTP.6.0");
603
+ }) ||
604
+ tryIt(function() {
605
+ return new ActiveXObject("Msxml2.XMLHTTP.3.0");
606
+ }) ||
607
+ tryIt(function() {
608
+ return new ActiveXObject("Msxml2.XMLHTTP");
609
+ }) ||
610
+ tryIt(function() {
611
+ return new ActiveXObject("Microsoft.XMLHTTP");
612
+ });
613
+
614
+ if (!xhr) throw new Error("This browser does not support XMLHttpRequest.");
615
+
616
+ return xhr;
617
+ } : XMLHttpRequest;
618
+ /**
619
+ * @namespace
620
+ */
621
+ jasmine.util = {};
622
+
623
+ /**
624
+ * Declare that a child class inherit it's prototype from the parent class.
625
+ *
626
+ * @private
627
+ * @param {Function} childClass
628
+ * @param {Function} parentClass
629
+ */
630
+ jasmine.util.inherit = function(childClass, parentClass) {
631
+ /**
632
+ * @private
633
+ */
634
+ var subclass = function() {
635
+ };
636
+ subclass.prototype = parentClass.prototype;
637
+ childClass.prototype = new subclass();
638
+ };
639
+
640
+ jasmine.util.formatException = function(e) {
641
+ var lineNumber;
642
+ if (e.line) {
643
+ lineNumber = e.line;
644
+ }
645
+ else if (e.lineNumber) {
646
+ lineNumber = e.lineNumber;
647
+ }
648
+
649
+ var file;
650
+
651
+ if (e.sourceURL) {
652
+ file = e.sourceURL;
653
+ }
654
+ else if (e.fileName) {
655
+ file = e.fileName;
656
+ }
657
+
658
+ var message = (e.name && e.message) ? (e.name + ': ' + e.message) : e.toString();
659
+
660
+ if (file && lineNumber) {
661
+ message += ' in ' + file + ' (line ' + lineNumber + ')';
662
+ }
663
+
664
+ return message;
665
+ };
666
+
667
+ jasmine.util.htmlEscape = function(str) {
668
+ if (!str) return str;
669
+ return str.replace(/&/g, '&amp;')
670
+ .replace(/</g, '&lt;')
671
+ .replace(/>/g, '&gt;');
672
+ };
673
+
674
+ jasmine.util.argsToArray = function(args) {
675
+ var arrayOfArgs = [];
676
+ for (var i = 0; i < args.length; i++) arrayOfArgs.push(args[i]);
677
+ return arrayOfArgs;
678
+ };
679
+
680
+ jasmine.util.extend = function(destination, source) {
681
+ for (var property in source) destination[property] = source[property];
682
+ return destination;
683
+ };
684
+
685
+ /**
686
+ * Environment for Jasmine
687
+ *
688
+ * @constructor
689
+ */
690
+ jasmine.Env = function() {
691
+ this.currentSpec = null;
692
+ this.currentSuite = null;
693
+ this.currentRunner_ = new jasmine.Runner(this);
694
+
695
+ this.reporter = new jasmine.MultiReporter();
696
+
697
+ this.updateInterval = jasmine.DEFAULT_UPDATE_INTERVAL;
698
+ this.defaultTimeoutInterval = jasmine.DEFAULT_TIMEOUT_INTERVAL;
699
+ this.lastUpdate = 0;
700
+ this.specFilter = function() {
701
+ return true;
702
+ };
703
+
704
+ this.nextSpecId_ = 0;
705
+ this.nextSuiteId_ = 0;
706
+ this.equalityTesters_ = [];
707
+
708
+ // wrap matchers
709
+ this.matchersClass = function() {
710
+ jasmine.Matchers.apply(this, arguments);
711
+ };
712
+ jasmine.util.inherit(this.matchersClass, jasmine.Matchers);
713
+
714
+ jasmine.Matchers.wrapInto_(jasmine.Matchers.prototype, this.matchersClass);
715
+ };
716
+
717
+
718
+ jasmine.Env.prototype.setTimeout = jasmine.setTimeout;
719
+ jasmine.Env.prototype.clearTimeout = jasmine.clearTimeout;
720
+ jasmine.Env.prototype.setInterval = jasmine.setInterval;
721
+ jasmine.Env.prototype.clearInterval = jasmine.clearInterval;
722
+
723
+ /**
724
+ * @returns an object containing jasmine version build info, if set.
725
+ */
726
+ jasmine.Env.prototype.version = function () {
727
+ if (jasmine.version_) {
728
+ return jasmine.version_;
729
+ } else {
730
+ throw new Error('Version not set');
731
+ }
732
+ };
733
+
734
+ /**
735
+ * @returns string containing jasmine version build info, if set.
736
+ */
737
+ jasmine.Env.prototype.versionString = function() {
738
+ if (!jasmine.version_) {
739
+ return "version unknown";
740
+ }
741
+
742
+ var version = this.version();
743
+ var versionString = version.major + "." + version.minor + "." + version.build;
744
+ if (version.release_candidate) {
745
+ versionString += ".rc" + version.release_candidate
746
+ }
747
+ versionString += " revision " + version.revision;
748
+ return versionString;
749
+ };
750
+
751
+ /**
752
+ * @returns a sequential integer starting at 0
753
+ */
754
+ jasmine.Env.prototype.nextSpecId = function () {
755
+ return this.nextSpecId_++;
756
+ };
757
+
758
+ /**
759
+ * @returns a sequential integer starting at 0
760
+ */
761
+ jasmine.Env.prototype.nextSuiteId = function () {
762
+ return this.nextSuiteId_++;
763
+ };
764
+
765
+ /**
766
+ * Register a reporter to receive status updates from Jasmine.
767
+ * @param {jasmine.Reporter} reporter An object which will receive status updates.
768
+ */
769
+ jasmine.Env.prototype.addReporter = function(reporter) {
770
+ this.reporter.addReporter(reporter);
771
+ };
772
+
773
+ jasmine.Env.prototype.execute = function() {
774
+ this.currentRunner_.execute();
775
+ };
776
+
777
+ jasmine.Env.prototype.describe = function(description, specDefinitions) {
778
+ var suite = new jasmine.Suite(this, description, specDefinitions, this.currentSuite);
779
+
780
+ var parentSuite = this.currentSuite;
781
+ if (parentSuite) {
782
+ parentSuite.add(suite);
783
+ } else {
784
+ this.currentRunner_.add(suite);
785
+ }
786
+
787
+ this.currentSuite = suite;
788
+
789
+ var declarationError = null;
790
+ try {
791
+ specDefinitions.call(suite);
792
+ } catch(e) {
793
+ declarationError = e;
794
+ }
795
+
796
+ if (declarationError) {
797
+ this.it("encountered a declaration exception", function() {
798
+ throw declarationError;
799
+ });
800
+ }
801
+
802
+ this.currentSuite = parentSuite;
803
+
804
+ return suite;
805
+ };
806
+
807
+ jasmine.Env.prototype.beforeEach = function(beforeEachFunction) {
808
+ if (this.currentSuite) {
809
+ this.currentSuite.beforeEach(beforeEachFunction);
810
+ } else {
811
+ this.currentRunner_.beforeEach(beforeEachFunction);
812
+ }
813
+ };
814
+
815
+ jasmine.Env.prototype.currentRunner = function () {
816
+ return this.currentRunner_;
817
+ };
818
+
819
+ jasmine.Env.prototype.afterEach = function(afterEachFunction) {
820
+ if (this.currentSuite) {
821
+ this.currentSuite.afterEach(afterEachFunction);
822
+ } else {
823
+ this.currentRunner_.afterEach(afterEachFunction);
824
+ }
825
+
826
+ };
827
+
828
+ jasmine.Env.prototype.xdescribe = function(desc, specDefinitions) {
829
+ return {
830
+ execute: function() {
831
+ }
832
+ };
833
+ };
834
+
835
+ jasmine.Env.prototype.it = function(description, func) {
836
+ var spec = new jasmine.Spec(this, this.currentSuite, description);
837
+ this.currentSuite.add(spec);
838
+ this.currentSpec = spec;
839
+
840
+ if (func) {
841
+ spec.runs(func);
842
+ }
843
+
844
+ return spec;
845
+ };
846
+
847
+ jasmine.Env.prototype.xit = function(desc, func) {
848
+ return {
849
+ id: this.nextSpecId(),
850
+ runs: function() {
851
+ }
852
+ };
853
+ };
854
+
855
+ jasmine.Env.prototype.compareObjects_ = function(a, b, mismatchKeys, mismatchValues) {
856
+ if (a.__Jasmine_been_here_before__ === b && b.__Jasmine_been_here_before__ === a) {
857
+ return true;
858
+ }
859
+
860
+ a.__Jasmine_been_here_before__ = b;
861
+ b.__Jasmine_been_here_before__ = a;
862
+
863
+ var hasKey = function(obj, keyName) {
864
+ return obj !== null && obj[keyName] !== jasmine.undefined;
865
+ };
866
+
867
+ for (var property in b) {
868
+ if (!hasKey(a, property) && hasKey(b, property)) {
869
+ mismatchKeys.push("expected has key '" + property + "', but missing from actual.");
870
+ }
871
+ }
872
+ for (property in a) {
873
+ if (!hasKey(b, property) && hasKey(a, property)) {
874
+ mismatchKeys.push("expected missing key '" + property + "', but present in actual.");
875
+ }
876
+ }
877
+ for (property in b) {
878
+ if (property == '__Jasmine_been_here_before__') continue;
879
+ if (!this.equals_(a[property], b[property], mismatchKeys, mismatchValues)) {
880
+ 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.");
881
+ }
882
+ }
883
+
884
+ if (jasmine.isArray_(a) && jasmine.isArray_(b) && a.length != b.length) {
885
+ mismatchValues.push("arrays were not the same length");
886
+ }
887
+
888
+ delete a.__Jasmine_been_here_before__;
889
+ delete b.__Jasmine_been_here_before__;
890
+ return (mismatchKeys.length === 0 && mismatchValues.length === 0);
891
+ };
892
+
893
+ jasmine.Env.prototype.equals_ = function(a, b, mismatchKeys, mismatchValues) {
894
+ mismatchKeys = mismatchKeys || [];
895
+ mismatchValues = mismatchValues || [];
896
+
897
+ for (var i = 0; i < this.equalityTesters_.length; i++) {
898
+ var equalityTester = this.equalityTesters_[i];
899
+ var result = equalityTester(a, b, this, mismatchKeys, mismatchValues);
900
+ if (result !== jasmine.undefined) return result;
901
+ }
902
+
903
+ if (a === b) return true;
904
+
905
+ if (a === jasmine.undefined || a === null || b === jasmine.undefined || b === null) {
906
+ return (a == jasmine.undefined && b == jasmine.undefined);
907
+ }
908
+
909
+ if (jasmine.isDomNode(a) && jasmine.isDomNode(b)) {
910
+ return a === b;
911
+ }
912
+
913
+ if (a instanceof Date && b instanceof Date) {
914
+ return a.getTime() == b.getTime();
915
+ }
916
+
917
+ if (a instanceof jasmine.Matchers.Any) {
918
+ return a.matches(b);
919
+ }
920
+
921
+ if (b instanceof jasmine.Matchers.Any) {
922
+ return b.matches(a);
923
+ }
924
+
925
+ if (jasmine.isString_(a) && jasmine.isString_(b)) {
926
+ return (a == b);
927
+ }
928
+
929
+ if (jasmine.isNumber_(a) && jasmine.isNumber_(b)) {
930
+ return (a == b);
931
+ }
932
+
933
+ if (typeof a === "object" && typeof b === "object") {
934
+ return this.compareObjects_(a, b, mismatchKeys, mismatchValues);
935
+ }
936
+
937
+ //Straight check
938
+ return (a === b);
939
+ };
940
+
941
+ jasmine.Env.prototype.contains_ = function(haystack, needle) {
942
+ if (jasmine.isArray_(haystack)) {
943
+ for (var i = 0; i < haystack.length; i++) {
944
+ if (this.equals_(haystack[i], needle)) return true;
945
+ }
946
+ return false;
947
+ }
948
+ return haystack.indexOf(needle) >= 0;
949
+ };
950
+
951
+ jasmine.Env.prototype.addEqualityTester = function(equalityTester) {
952
+ this.equalityTesters_.push(equalityTester);
953
+ };
954
+ /** No-op base class for Jasmine reporters.
955
+ *
956
+ * @constructor
957
+ */
958
+ jasmine.Reporter = function() {
959
+ };
960
+
961
+ //noinspection JSUnusedLocalSymbols
962
+ jasmine.Reporter.prototype.reportRunnerStarting = function(runner) {
963
+ };
964
+
965
+ //noinspection JSUnusedLocalSymbols
966
+ jasmine.Reporter.prototype.reportRunnerResults = function(runner) {
967
+ };
968
+
969
+ //noinspection JSUnusedLocalSymbols
970
+ jasmine.Reporter.prototype.reportSuiteResults = function(suite) {
971
+ };
972
+
973
+ //noinspection JSUnusedLocalSymbols
974
+ jasmine.Reporter.prototype.reportSpecStarting = function(spec) {
975
+ };
976
+
977
+ //noinspection JSUnusedLocalSymbols
978
+ jasmine.Reporter.prototype.reportSpecResults = function(spec) {
979
+ };
980
+
981
+ //noinspection JSUnusedLocalSymbols
982
+ jasmine.Reporter.prototype.log = function(str) {
983
+ };
984
+
985
+ /**
986
+ * Blocks are functions with executable code that make up a spec.
987
+ *
988
+ * @constructor
989
+ * @param {jasmine.Env} env
990
+ * @param {Function} func
991
+ * @param {jasmine.Spec} spec
992
+ */
993
+ jasmine.Block = function(env, func, spec) {
994
+ this.env = env;
995
+ this.func = func;
996
+ this.spec = spec;
997
+ };
998
+
999
+ jasmine.Block.prototype.execute = function(onComplete) {
1000
+ try {
1001
+ this.func.apply(this.spec);
1002
+ } catch (e) {
1003
+ this.spec.fail(e);
1004
+ }
1005
+ onComplete();
1006
+ };
1007
+ /** JavaScript API reporter.
1008
+ *
1009
+ * @constructor
1010
+ */
1011
+ jasmine.JsApiReporter = function() {
1012
+ this.started = false;
1013
+ this.finished = false;
1014
+ this.suites_ = [];
1015
+ this.results_ = {};
1016
+ };
1017
+
1018
+ jasmine.JsApiReporter.prototype.reportRunnerStarting = function(runner) {
1019
+ this.started = true;
1020
+ var suites = runner.topLevelSuites();
1021
+ for (var i = 0; i < suites.length; i++) {
1022
+ var suite = suites[i];
1023
+ this.suites_.push(this.summarize_(suite));
1024
+ }
1025
+ };
1026
+
1027
+ jasmine.JsApiReporter.prototype.suites = function() {
1028
+ return this.suites_;
1029
+ };
1030
+
1031
+ jasmine.JsApiReporter.prototype.summarize_ = function(suiteOrSpec) {
1032
+ var isSuite = suiteOrSpec instanceof jasmine.Suite;
1033
+ var summary = {
1034
+ id: suiteOrSpec.id,
1035
+ name: suiteOrSpec.description,
1036
+ type: isSuite ? 'suite' : 'spec',
1037
+ children: []
1038
+ };
1039
+
1040
+ if (isSuite) {
1041
+ var children = suiteOrSpec.children();
1042
+ for (var i = 0; i < children.length; i++) {
1043
+ summary.children.push(this.summarize_(children[i]));
1044
+ }
1045
+ }
1046
+ return summary;
1047
+ };
1048
+
1049
+ jasmine.JsApiReporter.prototype.results = function() {
1050
+ return this.results_;
1051
+ };
1052
+
1053
+ jasmine.JsApiReporter.prototype.resultsForSpec = function(specId) {
1054
+ return this.results_[specId];
1055
+ };
1056
+
1057
+ //noinspection JSUnusedLocalSymbols
1058
+ jasmine.JsApiReporter.prototype.reportRunnerResults = function(runner) {
1059
+ this.finished = true;
1060
+ };
1061
+
1062
+ //noinspection JSUnusedLocalSymbols
1063
+ jasmine.JsApiReporter.prototype.reportSuiteResults = function(suite) {
1064
+ };
1065
+
1066
+ //noinspection JSUnusedLocalSymbols
1067
+ jasmine.JsApiReporter.prototype.reportSpecResults = function(spec) {
1068
+ this.results_[spec.id] = {
1069
+ messages: spec.results().getItems(),
1070
+ result: spec.results().failedCount > 0 ? "failed" : "passed"
1071
+ };
1072
+ };
1073
+
1074
+ //noinspection JSUnusedLocalSymbols
1075
+ jasmine.JsApiReporter.prototype.log = function(str) {
1076
+ };
1077
+
1078
+ jasmine.JsApiReporter.prototype.resultsForSpecs = function(specIds){
1079
+ var results = {};
1080
+ for (var i = 0; i < specIds.length; i++) {
1081
+ var specId = specIds[i];
1082
+ results[specId] = this.summarizeResult_(this.results_[specId]);
1083
+ }
1084
+ return results;
1085
+ };
1086
+
1087
+ jasmine.JsApiReporter.prototype.summarizeResult_ = function(result){
1088
+ var summaryMessages = [];
1089
+ var messagesLength = result.messages.length;
1090
+ for (var messageIndex = 0; messageIndex < messagesLength; messageIndex++) {
1091
+ var resultMessage = result.messages[messageIndex];
1092
+ summaryMessages.push({
1093
+ text: resultMessage.type == 'log' ? resultMessage.toString() : jasmine.undefined,
1094
+ passed: resultMessage.passed ? resultMessage.passed() : true,
1095
+ type: resultMessage.type,
1096
+ message: resultMessage.message,
1097
+ trace: {
1098
+ stack: resultMessage.passed && !resultMessage.passed() ? resultMessage.trace.stack : jasmine.undefined
1099
+ }
1100
+ });
1101
+ }
1102
+
1103
+ return {
1104
+ result : result.result,
1105
+ messages : summaryMessages
1106
+ };
1107
+ };
1108
+
1109
+ /**
1110
+ * @constructor
1111
+ * @param {jasmine.Env} env
1112
+ * @param actual
1113
+ * @param {jasmine.Spec} spec
1114
+ */
1115
+ jasmine.Matchers = function(env, actual, spec, opt_isNot) {
1116
+ this.env = env;
1117
+ this.actual = actual;
1118
+ this.spec = spec;
1119
+ this.isNot = opt_isNot || false;
1120
+ this.reportWasCalled_ = false;
1121
+ };
1122
+
1123
+ // todo: @deprecated as of Jasmine 0.11, remove soon [xw]
1124
+ jasmine.Matchers.pp = function(str) {
1125
+ throw new Error("jasmine.Matchers.pp() is no longer supported, please use jasmine.pp() instead!");
1126
+ };
1127
+
1128
+ // todo: @deprecated Deprecated as of Jasmine 0.10. Rewrite your custom matchers to return true or false. [xw]
1129
+ jasmine.Matchers.prototype.report = function(result, failing_message, details) {
1130
+ throw new Error("As of jasmine 0.11, custom matchers must be implemented differently -- please see jasmine docs");
1131
+ };
1132
+
1133
+ jasmine.Matchers.wrapInto_ = function(prototype, matchersClass) {
1134
+ for (var methodName in prototype) {
1135
+ if (methodName == 'report') continue;
1136
+ var orig = prototype[methodName];
1137
+ matchersClass.prototype[methodName] = jasmine.Matchers.matcherFn_(methodName, orig);
1138
+ }
1139
+ };
1140
+
1141
+ jasmine.Matchers.matcherFn_ = function(matcherName, matcherFunction) {
1142
+ return function() {
1143
+ var matcherArgs = jasmine.util.argsToArray(arguments);
1144
+ var result = matcherFunction.apply(this, arguments);
1145
+
1146
+ if (this.isNot) {
1147
+ result = !result;
1148
+ }
1149
+
1150
+ if (this.reportWasCalled_) return result;
1151
+
1152
+ var message;
1153
+ if (!result) {
1154
+ if (this.message) {
1155
+ message = this.message.apply(this, arguments);
1156
+ if (jasmine.isArray_(message)) {
1157
+ message = message[this.isNot ? 1 : 0];
1158
+ }
1159
+ } else {
1160
+ var englishyPredicate = matcherName.replace(/[A-Z]/g, function(s) { return ' ' + s.toLowerCase(); });
1161
+ message = "Expected " + jasmine.pp(this.actual) + (this.isNot ? " not " : " ") + englishyPredicate;
1162
+ if (matcherArgs.length > 0) {
1163
+ for (var i = 0; i < matcherArgs.length; i++) {
1164
+ if (i > 0) message += ",";
1165
+ message += " " + jasmine.pp(matcherArgs[i]);
1166
+ }
1167
+ }
1168
+ message += ".";
1169
+ }
1170
+ }
1171
+ var expectationResult = new jasmine.ExpectationResult({
1172
+ matcherName: matcherName,
1173
+ passed: result,
1174
+ expected: matcherArgs.length > 1 ? matcherArgs : matcherArgs[0],
1175
+ actual: this.actual,
1176
+ message: message
1177
+ });
1178
+ this.spec.addMatcherResult(expectationResult);
1179
+ return jasmine.undefined;
1180
+ };
1181
+ };
1182
+
1183
+
1184
+
1185
+
1186
+ /**
1187
+ * toBe: compares the actual to the expected using ===
1188
+ * @param expected
1189
+ */
1190
+ jasmine.Matchers.prototype.toBe = function(expected) {
1191
+ return this.actual === expected;
1192
+ };
1193
+
1194
+ /**
1195
+ * toNotBe: compares the actual to the expected using !==
1196
+ * @param expected
1197
+ * @deprecated as of 1.0. Use not.toBe() instead.
1198
+ */
1199
+ jasmine.Matchers.prototype.toNotBe = function(expected) {
1200
+ return this.actual !== expected;
1201
+ };
1202
+
1203
+ /**
1204
+ * toEqual: compares the actual to the expected using common sense equality. Handles Objects, Arrays, etc.
1205
+ *
1206
+ * @param expected
1207
+ */
1208
+ jasmine.Matchers.prototype.toEqual = function(expected) {
1209
+ return this.env.equals_(this.actual, expected);
1210
+ };
1211
+
1212
+ /**
1213
+ * toNotEqual: compares the actual to the expected using the ! of jasmine.Matchers.toEqual
1214
+ * @param expected
1215
+ * @deprecated as of 1.0. Use not.toNotEqual() instead.
1216
+ */
1217
+ jasmine.Matchers.prototype.toNotEqual = function(expected) {
1218
+ return !this.env.equals_(this.actual, expected);
1219
+ };
1220
+
1221
+ /**
1222
+ * Matcher that compares the actual to the expected using a regular expression. Constructs a RegExp, so takes
1223
+ * a pattern or a String.
1224
+ *
1225
+ * @param expected
1226
+ */
1227
+ jasmine.Matchers.prototype.toMatch = function(expected) {
1228
+ return new RegExp(expected).test(this.actual);
1229
+ };
1230
+
1231
+ /**
1232
+ * Matcher that compares the actual to the expected using the boolean inverse of jasmine.Matchers.toMatch
1233
+ * @param expected
1234
+ * @deprecated as of 1.0. Use not.toMatch() instead.
1235
+ */
1236
+ jasmine.Matchers.prototype.toNotMatch = function(expected) {
1237
+ return !(new RegExp(expected).test(this.actual));
1238
+ };
1239
+
1240
+ /**
1241
+ * Matcher that compares the actual to jasmine.undefined.
1242
+ */
1243
+ jasmine.Matchers.prototype.toBeDefined = function() {
1244
+ return (this.actual !== jasmine.undefined);
1245
+ };
1246
+
1247
+ /**
1248
+ * Matcher that compares the actual to jasmine.undefined.
1249
+ */
1250
+ jasmine.Matchers.prototype.toBeUndefined = function() {
1251
+ return (this.actual === jasmine.undefined);
1252
+ };
1253
+
1254
+ /**
1255
+ * Matcher that compares the actual to null.
1256
+ */
1257
+ jasmine.Matchers.prototype.toBeNull = function() {
1258
+ return (this.actual === null);
1259
+ };
1260
+
1261
+ /**
1262
+ * Matcher that boolean not-nots the actual.
1263
+ */
1264
+ jasmine.Matchers.prototype.toBeTruthy = function() {
1265
+ return !!this.actual;
1266
+ };
1267
+
1268
+
1269
+ /**
1270
+ * Matcher that boolean nots the actual.
1271
+ */
1272
+ jasmine.Matchers.prototype.toBeFalsy = function() {
1273
+ return !this.actual;
1274
+ };
1275
+
1276
+
1277
+ /**
1278
+ * Matcher that checks to see if the actual, a Jasmine spy, was called.
1279
+ */
1280
+ jasmine.Matchers.prototype.toHaveBeenCalled = function() {
1281
+ if (arguments.length > 0) {
1282
+ throw new Error('toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith');
1283
+ }
1284
+
1285
+ if (!jasmine.isSpy(this.actual)) {
1286
+ throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
1287
+ }
1288
+
1289
+ this.message = function() {
1290
+ return [
1291
+ "Expected spy " + this.actual.identity + " to have been called.",
1292
+ "Expected spy " + this.actual.identity + " not to have been called."
1293
+ ];
1294
+ };
1295
+
1296
+ return this.actual.wasCalled;
1297
+ };
1298
+
1299
+ /** @deprecated Use expect(xxx).toHaveBeenCalled() instead */
1300
+ jasmine.Matchers.prototype.wasCalled = jasmine.Matchers.prototype.toHaveBeenCalled;
1301
+
1302
+ /**
1303
+ * Matcher that checks to see if the actual, a Jasmine spy, was not called.
1304
+ *
1305
+ * @deprecated Use expect(xxx).not.toHaveBeenCalled() instead
1306
+ */
1307
+ jasmine.Matchers.prototype.wasNotCalled = function() {
1308
+ if (arguments.length > 0) {
1309
+ throw new Error('wasNotCalled does not take arguments');
1310
+ }
1311
+
1312
+ if (!jasmine.isSpy(this.actual)) {
1313
+ throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
1314
+ }
1315
+
1316
+ this.message = function() {
1317
+ return [
1318
+ "Expected spy " + this.actual.identity + " to not have been called.",
1319
+ "Expected spy " + this.actual.identity + " to have been called."
1320
+ ];
1321
+ };
1322
+
1323
+ return !this.actual.wasCalled;
1324
+ };
1325
+
1326
+ /**
1327
+ * Matcher that checks to see if the actual, a Jasmine spy, was called with a set of parameters.
1328
+ *
1329
+ * @example
1330
+ *
1331
+ */
1332
+ jasmine.Matchers.prototype.toHaveBeenCalledWith = function() {
1333
+ var expectedArgs = jasmine.util.argsToArray(arguments);
1334
+ if (!jasmine.isSpy(this.actual)) {
1335
+ throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
1336
+ }
1337
+ this.message = function() {
1338
+ if (this.actual.callCount === 0) {
1339
+ // todo: what should the failure message for .not.toHaveBeenCalledWith() be? is this right? test better. [xw]
1340
+ return [
1341
+ "Expected spy " + this.actual.identity + " to have been called with " + jasmine.pp(expectedArgs) + " but it was never called.",
1342
+ "Expected spy " + this.actual.identity + " not to have been called with " + jasmine.pp(expectedArgs) + " but it was."
1343
+ ];
1344
+ } else {
1345
+ return [
1346
+ "Expected spy " + this.actual.identity + " to have been called with " + jasmine.pp(expectedArgs) + " but was called with " + jasmine.pp(this.actual.argsForCall),
1347
+ "Expected spy " + this.actual.identity + " not to have been called with " + jasmine.pp(expectedArgs) + " but was called with " + jasmine.pp(this.actual.argsForCall)
1348
+ ];
1349
+ }
1350
+ };
1351
+
1352
+ return this.env.contains_(this.actual.argsForCall, expectedArgs);
1353
+ };
1354
+
1355
+ /** @deprecated Use expect(xxx).toHaveBeenCalledWith() instead */
1356
+ jasmine.Matchers.prototype.wasCalledWith = jasmine.Matchers.prototype.toHaveBeenCalledWith;
1357
+
1358
+ /** @deprecated Use expect(xxx).not.toHaveBeenCalledWith() instead */
1359
+ jasmine.Matchers.prototype.wasNotCalledWith = function() {
1360
+ var expectedArgs = jasmine.util.argsToArray(arguments);
1361
+ if (!jasmine.isSpy(this.actual)) {
1362
+ throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
1363
+ }
1364
+
1365
+ this.message = function() {
1366
+ return [
1367
+ "Expected spy not to have been called with " + jasmine.pp(expectedArgs) + " but it was",
1368
+ "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but it was"
1369
+ ];
1370
+ };
1371
+
1372
+ return !this.env.contains_(this.actual.argsForCall, expectedArgs);
1373
+ };
1374
+
1375
+ /**
1376
+ * Matcher that checks that the expected item is an element in the actual Array.
1377
+ *
1378
+ * @param {Object} expected
1379
+ */
1380
+ jasmine.Matchers.prototype.toContain = function(expected) {
1381
+ return this.env.contains_(this.actual, expected);
1382
+ };
1383
+
1384
+ /**
1385
+ * Matcher that checks that the expected item is NOT an element in the actual Array.
1386
+ *
1387
+ * @param {Object} expected
1388
+ * @deprecated as of 1.0. Use not.toNotContain() instead.
1389
+ */
1390
+ jasmine.Matchers.prototype.toNotContain = function(expected) {
1391
+ return !this.env.contains_(this.actual, expected);
1392
+ };
1393
+
1394
+ jasmine.Matchers.prototype.toBeLessThan = function(expected) {
1395
+ return this.actual < expected;
1396
+ };
1397
+
1398
+ jasmine.Matchers.prototype.toBeGreaterThan = function(expected) {
1399
+ return this.actual > expected;
1400
+ };
1401
+
1402
+ /**
1403
+ * Matcher that checks that the expected item is equal to the actual item
1404
+ * up to a given level of decimal precision (default 2).
1405
+ *
1406
+ * @param {Number} expected
1407
+ * @param {Number} precision
1408
+ */
1409
+ jasmine.Matchers.prototype.toBeCloseTo = function(expected, precision) {
1410
+ if (!(precision === 0)) {
1411
+ precision = precision || 2;
1412
+ }
1413
+ var multiplier = Math.pow(10, precision);
1414
+ var actual = Math.round(this.actual * multiplier);
1415
+ expected = Math.round(expected * multiplier);
1416
+ return expected == actual;
1417
+ };
1418
+
1419
+ /**
1420
+ * Matcher that checks that the expected exception was thrown by the actual.
1421
+ *
1422
+ * @param {String} expected
1423
+ */
1424
+ jasmine.Matchers.prototype.toThrow = function(expected) {
1425
+ var result = false;
1426
+ var exception;
1427
+ if (typeof this.actual != 'function') {
1428
+ throw new Error('Actual is not a function');
1429
+ }
1430
+ try {
1431
+ this.actual();
1432
+ } catch (e) {
1433
+ exception = e;
1434
+ }
1435
+ if (exception) {
1436
+ result = (expected === jasmine.undefined || this.env.equals_(exception.message || exception, expected.message || expected));
1437
+ }
1438
+
1439
+ var not = this.isNot ? "not " : "";
1440
+
1441
+ this.message = function() {
1442
+ if (exception && (expected === jasmine.undefined || !this.env.equals_(exception.message || exception, expected.message || expected))) {
1443
+ return ["Expected function " + not + "to throw", expected ? expected.message || expected : "an exception", ", but it threw", exception.message || exception].join(' ');
1444
+ } else {
1445
+ return "Expected function to throw an exception.";
1446
+ }
1447
+ };
1448
+
1449
+ return result;
1450
+ };
1451
+
1452
+ jasmine.Matchers.Any = function(expectedClass) {
1453
+ this.expectedClass = expectedClass;
1454
+ };
1455
+
1456
+ jasmine.Matchers.Any.prototype.matches = function(other) {
1457
+ if (this.expectedClass == String) {
1458
+ return typeof other == 'string' || other instanceof String;
1459
+ }
1460
+
1461
+ if (this.expectedClass == Number) {
1462
+ return typeof other == 'number' || other instanceof Number;
1463
+ }
1464
+
1465
+ if (this.expectedClass == Function) {
1466
+ return typeof other == 'function' || other instanceof Function;
1467
+ }
1468
+
1469
+ if (this.expectedClass == Object) {
1470
+ return typeof other == 'object';
1471
+ }
1472
+
1473
+ return other instanceof this.expectedClass;
1474
+ };
1475
+
1476
+ jasmine.Matchers.Any.prototype.toString = function() {
1477
+ return '<jasmine.any(' + this.expectedClass + ')>';
1478
+ };
1479
+
1480
+ /**
1481
+ * @constructor
1482
+ */
1483
+ jasmine.MultiReporter = function() {
1484
+ this.subReporters_ = [];
1485
+ };
1486
+ jasmine.util.inherit(jasmine.MultiReporter, jasmine.Reporter);
1487
+
1488
+ jasmine.MultiReporter.prototype.addReporter = function(reporter) {
1489
+ this.subReporters_.push(reporter);
1490
+ };
1491
+
1492
+ (function() {
1493
+ var functionNames = [
1494
+ "reportRunnerStarting",
1495
+ "reportRunnerResults",
1496
+ "reportSuiteResults",
1497
+ "reportSpecStarting",
1498
+ "reportSpecResults",
1499
+ "log"
1500
+ ];
1501
+ for (var i = 0; i < functionNames.length; i++) {
1502
+ var functionName = functionNames[i];
1503
+ jasmine.MultiReporter.prototype[functionName] = (function(functionName) {
1504
+ return function() {
1505
+ for (var j = 0; j < this.subReporters_.length; j++) {
1506
+ var subReporter = this.subReporters_[j];
1507
+ if (subReporter[functionName]) {
1508
+ subReporter[functionName].apply(subReporter, arguments);
1509
+ }
1510
+ }
1511
+ };
1512
+ })(functionName);
1513
+ }
1514
+ })();
1515
+ /**
1516
+ * Holds results for a set of Jasmine spec. Allows for the results array to hold another jasmine.NestedResults
1517
+ *
1518
+ * @constructor
1519
+ */
1520
+ jasmine.NestedResults = function() {
1521
+ /**
1522
+ * The total count of results
1523
+ */
1524
+ this.totalCount = 0;
1525
+ /**
1526
+ * Number of passed results
1527
+ */
1528
+ this.passedCount = 0;
1529
+ /**
1530
+ * Number of failed results
1531
+ */
1532
+ this.failedCount = 0;
1533
+ /**
1534
+ * Was this suite/spec skipped?
1535
+ */
1536
+ this.skipped = false;
1537
+ /**
1538
+ * @ignore
1539
+ */
1540
+ this.items_ = [];
1541
+ };
1542
+
1543
+ /**
1544
+ * Roll up the result counts.
1545
+ *
1546
+ * @param result
1547
+ */
1548
+ jasmine.NestedResults.prototype.rollupCounts = function(result) {
1549
+ this.totalCount += result.totalCount;
1550
+ this.passedCount += result.passedCount;
1551
+ this.failedCount += result.failedCount;
1552
+ };
1553
+
1554
+ /**
1555
+ * Adds a log message.
1556
+ * @param values Array of message parts which will be concatenated later.
1557
+ */
1558
+ jasmine.NestedResults.prototype.log = function(values) {
1559
+ this.items_.push(new jasmine.MessageResult(values));
1560
+ };
1561
+
1562
+ /**
1563
+ * Getter for the results: message & results.
1564
+ */
1565
+ jasmine.NestedResults.prototype.getItems = function() {
1566
+ return this.items_;
1567
+ };
1568
+
1569
+ /**
1570
+ * Adds a result, tracking counts (total, passed, & failed)
1571
+ * @param {jasmine.ExpectationResult|jasmine.NestedResults} result
1572
+ */
1573
+ jasmine.NestedResults.prototype.addResult = function(result) {
1574
+ if (result.type != 'log') {
1575
+ if (result.items_) {
1576
+ this.rollupCounts(result);
1577
+ } else {
1578
+ this.totalCount++;
1579
+ if (result.passed()) {
1580
+ this.passedCount++;
1581
+ } else {
1582
+ this.failedCount++;
1583
+ }
1584
+ }
1585
+ }
1586
+ this.items_.push(result);
1587
+ };
1588
+
1589
+ /**
1590
+ * @returns {Boolean} True if <b>everything</b> below passed
1591
+ */
1592
+ jasmine.NestedResults.prototype.passed = function() {
1593
+ return this.passedCount === this.totalCount;
1594
+ };
1595
+ /**
1596
+ * Base class for pretty printing for expectation results.
1597
+ */
1598
+ jasmine.PrettyPrinter = function() {
1599
+ this.ppNestLevel_ = 0;
1600
+ };
1601
+
1602
+ /**
1603
+ * Formats a value in a nice, human-readable string.
1604
+ *
1605
+ * @param value
1606
+ */
1607
+ jasmine.PrettyPrinter.prototype.format = function(value) {
1608
+ if (this.ppNestLevel_ > 40) {
1609
+ throw new Error('jasmine.PrettyPrinter: format() nested too deeply!');
1610
+ }
1611
+
1612
+ this.ppNestLevel_++;
1613
+ try {
1614
+ if (value === jasmine.undefined) {
1615
+ this.emitScalar('undefined');
1616
+ } else if (value === null) {
1617
+ this.emitScalar('null');
1618
+ } else if (value === jasmine.getGlobal()) {
1619
+ this.emitScalar('<global>');
1620
+ } else if (value instanceof jasmine.Matchers.Any) {
1621
+ this.emitScalar(value.toString());
1622
+ } else if (typeof value === 'string') {
1623
+ this.emitString(value);
1624
+ } else if (jasmine.isSpy(value)) {
1625
+ this.emitScalar("spy on " + value.identity);
1626
+ } else if (value instanceof RegExp) {
1627
+ this.emitScalar(value.toString());
1628
+ } else if (typeof value === 'function') {
1629
+ this.emitScalar('Function');
1630
+ } else if (typeof value.nodeType === 'number') {
1631
+ this.emitScalar('HTMLNode');
1632
+ } else if (value instanceof Date) {
1633
+ this.emitScalar('Date(' + value + ')');
1634
+ } else if (value.__Jasmine_been_here_before__) {
1635
+ this.emitScalar('<circular reference: ' + (jasmine.isArray_(value) ? 'Array' : 'Object') + '>');
1636
+ } else if (jasmine.isArray_(value) || typeof value == 'object') {
1637
+ value.__Jasmine_been_here_before__ = true;
1638
+ if (jasmine.isArray_(value)) {
1639
+ this.emitArray(value);
1640
+ } else {
1641
+ this.emitObject(value);
1642
+ }
1643
+ delete value.__Jasmine_been_here_before__;
1644
+ } else {
1645
+ this.emitScalar(value.toString());
1646
+ }
1647
+ } finally {
1648
+ this.ppNestLevel_--;
1649
+ }
1650
+ };
1651
+
1652
+ jasmine.PrettyPrinter.prototype.iterateObject = function(obj, fn) {
1653
+ for (var property in obj) {
1654
+ if (property == '__Jasmine_been_here_before__') continue;
1655
+ fn(property, obj.__lookupGetter__ ? (obj.__lookupGetter__(property) !== jasmine.undefined &&
1656
+ obj.__lookupGetter__(property) !== null) : false);
1657
+ }
1658
+ };
1659
+
1660
+ jasmine.PrettyPrinter.prototype.emitArray = jasmine.unimplementedMethod_;
1661
+ jasmine.PrettyPrinter.prototype.emitObject = jasmine.unimplementedMethod_;
1662
+ jasmine.PrettyPrinter.prototype.emitScalar = jasmine.unimplementedMethod_;
1663
+ jasmine.PrettyPrinter.prototype.emitString = jasmine.unimplementedMethod_;
1664
+
1665
+ jasmine.StringPrettyPrinter = function() {
1666
+ jasmine.PrettyPrinter.call(this);
1667
+
1668
+ this.string = '';
1669
+ };
1670
+ jasmine.util.inherit(jasmine.StringPrettyPrinter, jasmine.PrettyPrinter);
1671
+
1672
+ jasmine.StringPrettyPrinter.prototype.emitScalar = function(value) {
1673
+ this.append(value);
1674
+ };
1675
+
1676
+ jasmine.StringPrettyPrinter.prototype.emitString = function(value) {
1677
+ this.append("'" + value + "'");
1678
+ };
1679
+
1680
+ jasmine.StringPrettyPrinter.prototype.emitArray = function(array) {
1681
+ this.append('[ ');
1682
+ for (var i = 0; i < array.length; i++) {
1683
+ if (i > 0) {
1684
+ this.append(', ');
1685
+ }
1686
+ this.format(array[i]);
1687
+ }
1688
+ this.append(' ]');
1689
+ };
1690
+
1691
+ jasmine.StringPrettyPrinter.prototype.emitObject = function(obj) {
1692
+ var self = this;
1693
+ this.append('{ ');
1694
+ var first = true;
1695
+
1696
+ this.iterateObject(obj, function(property, isGetter) {
1697
+ if (first) {
1698
+ first = false;
1699
+ } else {
1700
+ self.append(', ');
1701
+ }
1702
+
1703
+ self.append(property);
1704
+ self.append(' : ');
1705
+ if (isGetter) {
1706
+ self.append('<getter>');
1707
+ } else {
1708
+ self.format(obj[property]);
1709
+ }
1710
+ });
1711
+
1712
+ this.append(' }');
1713
+ };
1714
+
1715
+ jasmine.StringPrettyPrinter.prototype.append = function(value) {
1716
+ this.string += value;
1717
+ };
1718
+ jasmine.Queue = function(env) {
1719
+ this.env = env;
1720
+ this.blocks = [];
1721
+ this.running = false;
1722
+ this.index = 0;
1723
+ this.offset = 0;
1724
+ this.abort = false;
1725
+ };
1726
+
1727
+ jasmine.Queue.prototype.addBefore = function(block) {
1728
+ this.blocks.unshift(block);
1729
+ };
1730
+
1731
+ jasmine.Queue.prototype.add = function(block) {
1732
+ this.blocks.push(block);
1733
+ };
1734
+
1735
+ jasmine.Queue.prototype.insertNext = function(block) {
1736
+ this.blocks.splice((this.index + this.offset + 1), 0, block);
1737
+ this.offset++;
1738
+ };
1739
+
1740
+ jasmine.Queue.prototype.start = function(onComplete) {
1741
+ this.running = true;
1742
+ this.onComplete = onComplete;
1743
+ this.next_();
1744
+ };
1745
+
1746
+ jasmine.Queue.prototype.isRunning = function() {
1747
+ return this.running;
1748
+ };
1749
+
1750
+ jasmine.Queue.LOOP_DONT_RECURSE = true;
1751
+
1752
+ jasmine.Queue.prototype.next_ = function() {
1753
+ var self = this;
1754
+ var goAgain = true;
1755
+
1756
+ while (goAgain) {
1757
+ goAgain = false;
1758
+
1759
+ if (self.index < self.blocks.length && !this.abort) {
1760
+ var calledSynchronously = true;
1761
+ var completedSynchronously = false;
1762
+
1763
+ var onComplete = function () {
1764
+ if (jasmine.Queue.LOOP_DONT_RECURSE && calledSynchronously) {
1765
+ completedSynchronously = true;
1766
+ return;
1767
+ }
1768
+
1769
+ if (self.blocks[self.index].abort) {
1770
+ self.abort = true;
1771
+ }
1772
+
1773
+ self.offset = 0;
1774
+ self.index++;
1775
+
1776
+ var now = new Date().getTime();
1777
+ if (self.env.updateInterval && now - self.env.lastUpdate > self.env.updateInterval) {
1778
+ self.env.lastUpdate = now;
1779
+ self.env.setTimeout(function() {
1780
+ self.next_();
1781
+ }, 0);
1782
+ } else {
1783
+ if (jasmine.Queue.LOOP_DONT_RECURSE && completedSynchronously) {
1784
+ goAgain = true;
1785
+ } else {
1786
+ self.next_();
1787
+ }
1788
+ }
1789
+ };
1790
+ self.blocks[self.index].execute(onComplete);
1791
+
1792
+ calledSynchronously = false;
1793
+ if (completedSynchronously) {
1794
+ onComplete();
1795
+ }
1796
+
1797
+ } else {
1798
+ self.running = false;
1799
+ if (self.onComplete) {
1800
+ self.onComplete();
1801
+ }
1802
+ }
1803
+ }
1804
+ };
1805
+
1806
+ jasmine.Queue.prototype.results = function() {
1807
+ var results = new jasmine.NestedResults();
1808
+ for (var i = 0; i < this.blocks.length; i++) {
1809
+ if (this.blocks[i].results) {
1810
+ results.addResult(this.blocks[i].results());
1811
+ }
1812
+ }
1813
+ return results;
1814
+ };
1815
+
1816
+
1817
+ /**
1818
+ * Runner
1819
+ *
1820
+ * @constructor
1821
+ * @param {jasmine.Env} env
1822
+ */
1823
+ jasmine.Runner = function(env) {
1824
+ var self = this;
1825
+ self.env = env;
1826
+ self.queue = new jasmine.Queue(env);
1827
+ self.before_ = [];
1828
+ self.after_ = [];
1829
+ self.suites_ = [];
1830
+ };
1831
+
1832
+ jasmine.Runner.prototype.execute = function() {
1833
+ var self = this;
1834
+ if (self.env.reporter.reportRunnerStarting) {
1835
+ self.env.reporter.reportRunnerStarting(this);
1836
+ }
1837
+ self.queue.start(function () {
1838
+ self.finishCallback();
1839
+ });
1840
+ };
1841
+
1842
+ jasmine.Runner.prototype.beforeEach = function(beforeEachFunction) {
1843
+ beforeEachFunction.typeName = 'beforeEach';
1844
+ this.before_.splice(0,0,beforeEachFunction);
1845
+ };
1846
+
1847
+ jasmine.Runner.prototype.afterEach = function(afterEachFunction) {
1848
+ afterEachFunction.typeName = 'afterEach';
1849
+ this.after_.splice(0,0,afterEachFunction);
1850
+ };
1851
+
1852
+
1853
+ jasmine.Runner.prototype.finishCallback = function() {
1854
+ this.env.reporter.reportRunnerResults(this);
1855
+ };
1856
+
1857
+ jasmine.Runner.prototype.addSuite = function(suite) {
1858
+ this.suites_.push(suite);
1859
+ };
1860
+
1861
+ jasmine.Runner.prototype.add = function(block) {
1862
+ if (block instanceof jasmine.Suite) {
1863
+ this.addSuite(block);
1864
+ }
1865
+ this.queue.add(block);
1866
+ };
1867
+
1868
+ jasmine.Runner.prototype.specs = function () {
1869
+ var suites = this.suites();
1870
+ var specs = [];
1871
+ for (var i = 0; i < suites.length; i++) {
1872
+ specs = specs.concat(suites[i].specs());
1873
+ }
1874
+ return specs;
1875
+ };
1876
+
1877
+ jasmine.Runner.prototype.suites = function() {
1878
+ return this.suites_;
1879
+ };
1880
+
1881
+ jasmine.Runner.prototype.topLevelSuites = function() {
1882
+ var topLevelSuites = [];
1883
+ for (var i = 0; i < this.suites_.length; i++) {
1884
+ if (!this.suites_[i].parentSuite) {
1885
+ topLevelSuites.push(this.suites_[i]);
1886
+ }
1887
+ }
1888
+ return topLevelSuites;
1889
+ };
1890
+
1891
+ jasmine.Runner.prototype.results = function() {
1892
+ return this.queue.results();
1893
+ };
1894
+ /**
1895
+ * Internal representation of a Jasmine specification, or test.
1896
+ *
1897
+ * @constructor
1898
+ * @param {jasmine.Env} env
1899
+ * @param {jasmine.Suite} suite
1900
+ * @param {String} description
1901
+ */
1902
+ jasmine.Spec = function(env, suite, description) {
1903
+ if (!env) {
1904
+ throw new Error('jasmine.Env() required');
1905
+ }
1906
+ if (!suite) {
1907
+ throw new Error('jasmine.Suite() required');
1908
+ }
1909
+ var spec = this;
1910
+ spec.id = env.nextSpecId ? env.nextSpecId() : null;
1911
+ spec.env = env;
1912
+ spec.suite = suite;
1913
+ spec.description = description;
1914
+ spec.queue = new jasmine.Queue(env);
1915
+
1916
+ spec.afterCallbacks = [];
1917
+ spec.spies_ = [];
1918
+
1919
+ spec.results_ = new jasmine.NestedResults();
1920
+ spec.results_.description = description;
1921
+ spec.matchersClass = null;
1922
+ };
1923
+
1924
+ jasmine.Spec.prototype.getFullName = function() {
1925
+ return this.suite.getFullName() + ' ' + this.description + '.';
1926
+ };
1927
+
1928
+
1929
+ jasmine.Spec.prototype.results = function() {
1930
+ return this.results_;
1931
+ };
1932
+
1933
+ /**
1934
+ * All parameters are pretty-printed and concatenated together, then written to the spec's output.
1935
+ *
1936
+ * Be careful not to leave calls to <code>jasmine.log</code> in production code.
1937
+ */
1938
+ jasmine.Spec.prototype.log = function() {
1939
+ return this.results_.log(arguments);
1940
+ };
1941
+
1942
+ jasmine.Spec.prototype.runs = function (func) {
1943
+ var block = new jasmine.Block(this.env, func, this);
1944
+ this.addToQueue(block);
1945
+ return this;
1946
+ };
1947
+
1948
+ jasmine.Spec.prototype.addToQueue = function (block) {
1949
+ if (this.queue.isRunning()) {
1950
+ this.queue.insertNext(block);
1951
+ } else {
1952
+ this.queue.add(block);
1953
+ }
1954
+ };
1955
+
1956
+ /**
1957
+ * @param {jasmine.ExpectationResult} result
1958
+ */
1959
+ jasmine.Spec.prototype.addMatcherResult = function(result) {
1960
+ this.results_.addResult(result);
1961
+ };
1962
+
1963
+ jasmine.Spec.prototype.expect = function(actual) {
1964
+ var positive = new (this.getMatchersClass_())(this.env, actual, this);
1965
+ positive.not = new (this.getMatchersClass_())(this.env, actual, this, true);
1966
+ return positive;
1967
+ };
1968
+
1969
+ /**
1970
+ * Waits a fixed time period before moving to the next block.
1971
+ *
1972
+ * @deprecated Use waitsFor() instead
1973
+ * @param {Number} timeout milliseconds to wait
1974
+ */
1975
+ jasmine.Spec.prototype.waits = function(timeout) {
1976
+ var waitsFunc = new jasmine.WaitsBlock(this.env, timeout, this);
1977
+ this.addToQueue(waitsFunc);
1978
+ return this;
1979
+ };
1980
+
1981
+ /**
1982
+ * Waits for the latchFunction to return true before proceeding to the next block.
1983
+ *
1984
+ * @param {Function} latchFunction
1985
+ * @param {String} optional_timeoutMessage
1986
+ * @param {Number} optional_timeout
1987
+ */
1988
+ jasmine.Spec.prototype.waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) {
1989
+ var latchFunction_ = null;
1990
+ var optional_timeoutMessage_ = null;
1991
+ var optional_timeout_ = null;
1992
+
1993
+ for (var i = 0; i < arguments.length; i++) {
1994
+ var arg = arguments[i];
1995
+ switch (typeof arg) {
1996
+ case 'function':
1997
+ latchFunction_ = arg;
1998
+ break;
1999
+ case 'string':
2000
+ optional_timeoutMessage_ = arg;
2001
+ break;
2002
+ case 'number':
2003
+ optional_timeout_ = arg;
2004
+ break;
2005
+ }
2006
+ }
2007
+
2008
+ var waitsForFunc = new jasmine.WaitsForBlock(this.env, optional_timeout_, latchFunction_, optional_timeoutMessage_, this);
2009
+ this.addToQueue(waitsForFunc);
2010
+ return this;
2011
+ };
2012
+
2013
+ jasmine.Spec.prototype.fail = function (e) {
2014
+ var expectationResult = new jasmine.ExpectationResult({
2015
+ passed: false,
2016
+ message: e ? jasmine.util.formatException(e) : 'Exception',
2017
+ trace: { stack: e.stack }
2018
+ });
2019
+ this.results_.addResult(expectationResult);
2020
+ };
2021
+
2022
+ jasmine.Spec.prototype.getMatchersClass_ = function() {
2023
+ return this.matchersClass || this.env.matchersClass;
2024
+ };
2025
+
2026
+ jasmine.Spec.prototype.addMatchers = function(matchersPrototype) {
2027
+ var parent = this.getMatchersClass_();
2028
+ var newMatchersClass = function() {
2029
+ parent.apply(this, arguments);
2030
+ };
2031
+ jasmine.util.inherit(newMatchersClass, parent);
2032
+ jasmine.Matchers.wrapInto_(matchersPrototype, newMatchersClass);
2033
+ this.matchersClass = newMatchersClass;
2034
+ };
2035
+
2036
+ jasmine.Spec.prototype.finishCallback = function() {
2037
+ this.env.reporter.reportSpecResults(this);
2038
+ };
2039
+
2040
+ jasmine.Spec.prototype.finish = function(onComplete) {
2041
+ this.removeAllSpies();
2042
+ this.finishCallback();
2043
+ if (onComplete) {
2044
+ onComplete();
2045
+ }
2046
+ };
2047
+
2048
+ jasmine.Spec.prototype.after = function(doAfter) {
2049
+ if (this.queue.isRunning()) {
2050
+ this.queue.add(new jasmine.Block(this.env, doAfter, this));
2051
+ } else {
2052
+ this.afterCallbacks.unshift(doAfter);
2053
+ }
2054
+ };
2055
+
2056
+ jasmine.Spec.prototype.execute = function(onComplete) {
2057
+ var spec = this;
2058
+ if (!spec.env.specFilter(spec)) {
2059
+ spec.results_.skipped = true;
2060
+ spec.finish(onComplete);
2061
+ return;
2062
+ }
2063
+
2064
+ this.env.reporter.reportSpecStarting(this);
2065
+
2066
+ spec.env.currentSpec = spec;
2067
+
2068
+ spec.addBeforesAndAftersToQueue();
2069
+
2070
+ spec.queue.start(function () {
2071
+ spec.finish(onComplete);
2072
+ });
2073
+ };
2074
+
2075
+ jasmine.Spec.prototype.addBeforesAndAftersToQueue = function() {
2076
+ var runner = this.env.currentRunner();
2077
+ var i;
2078
+
2079
+ for (var suite = this.suite; suite; suite = suite.parentSuite) {
2080
+ for (i = 0; i < suite.before_.length; i++) {
2081
+ this.queue.addBefore(new jasmine.Block(this.env, suite.before_[i], this));
2082
+ }
2083
+ }
2084
+ for (i = 0; i < runner.before_.length; i++) {
2085
+ this.queue.addBefore(new jasmine.Block(this.env, runner.before_[i], this));
2086
+ }
2087
+ for (i = 0; i < this.afterCallbacks.length; i++) {
2088
+ this.queue.add(new jasmine.Block(this.env, this.afterCallbacks[i], this));
2089
+ }
2090
+ for (suite = this.suite; suite; suite = suite.parentSuite) {
2091
+ for (i = 0; i < suite.after_.length; i++) {
2092
+ this.queue.add(new jasmine.Block(this.env, suite.after_[i], this));
2093
+ }
2094
+ }
2095
+ for (i = 0; i < runner.after_.length; i++) {
2096
+ this.queue.add(new jasmine.Block(this.env, runner.after_[i], this));
2097
+ }
2098
+ };
2099
+
2100
+ jasmine.Spec.prototype.explodes = function() {
2101
+ throw 'explodes function should not have been called';
2102
+ };
2103
+
2104
+ jasmine.Spec.prototype.spyOn = function(obj, methodName, ignoreMethodDoesntExist) {
2105
+ if (obj == jasmine.undefined) {
2106
+ throw "spyOn could not find an object to spy upon for " + methodName + "()";
2107
+ }
2108
+
2109
+ if (!ignoreMethodDoesntExist && obj[methodName] === jasmine.undefined) {
2110
+ throw methodName + '() method does not exist';
2111
+ }
2112
+
2113
+ if (!ignoreMethodDoesntExist && obj[methodName] && obj[methodName].isSpy) {
2114
+ throw new Error(methodName + ' has already been spied upon');
2115
+ }
2116
+
2117
+ var spyObj = jasmine.createSpy(methodName);
2118
+
2119
+ this.spies_.push(spyObj);
2120
+ spyObj.baseObj = obj;
2121
+ spyObj.methodName = methodName;
2122
+ spyObj.originalValue = obj[methodName];
2123
+
2124
+ obj[methodName] = spyObj;
2125
+
2126
+ return spyObj;
2127
+ };
2128
+
2129
+ jasmine.Spec.prototype.removeAllSpies = function() {
2130
+ for (var i = 0; i < this.spies_.length; i++) {
2131
+ var spy = this.spies_[i];
2132
+ spy.baseObj[spy.methodName] = spy.originalValue;
2133
+ }
2134
+ this.spies_ = [];
2135
+ };
2136
+
2137
+ /**
2138
+ * Internal representation of a Jasmine suite.
2139
+ *
2140
+ * @constructor
2141
+ * @param {jasmine.Env} env
2142
+ * @param {String} description
2143
+ * @param {Function} specDefinitions
2144
+ * @param {jasmine.Suite} parentSuite
2145
+ */
2146
+ jasmine.Suite = function(env, description, specDefinitions, parentSuite) {
2147
+ var self = this;
2148
+ self.id = env.nextSuiteId ? env.nextSuiteId() : null;
2149
+ self.description = description;
2150
+ self.queue = new jasmine.Queue(env);
2151
+ self.parentSuite = parentSuite;
2152
+ self.env = env;
2153
+ self.before_ = [];
2154
+ self.after_ = [];
2155
+ self.children_ = [];
2156
+ self.suites_ = [];
2157
+ self.specs_ = [];
2158
+ };
2159
+
2160
+ jasmine.Suite.prototype.getFullName = function() {
2161
+ var fullName = this.description;
2162
+ for (var parentSuite = this.parentSuite; parentSuite; parentSuite = parentSuite.parentSuite) {
2163
+ fullName = parentSuite.description + ' ' + fullName;
2164
+ }
2165
+ return fullName;
2166
+ };
2167
+
2168
+ jasmine.Suite.prototype.finish = function(onComplete) {
2169
+ this.env.reporter.reportSuiteResults(this);
2170
+ this.finished = true;
2171
+ if (typeof(onComplete) == 'function') {
2172
+ onComplete();
2173
+ }
2174
+ };
2175
+
2176
+ jasmine.Suite.prototype.beforeEach = function(beforeEachFunction) {
2177
+ beforeEachFunction.typeName = 'beforeEach';
2178
+ this.before_.unshift(beforeEachFunction);
2179
+ };
2180
+
2181
+ jasmine.Suite.prototype.afterEach = function(afterEachFunction) {
2182
+ afterEachFunction.typeName = 'afterEach';
2183
+ this.after_.unshift(afterEachFunction);
2184
+ };
2185
+
2186
+ jasmine.Suite.prototype.results = function() {
2187
+ return this.queue.results();
2188
+ };
2189
+
2190
+ jasmine.Suite.prototype.add = function(suiteOrSpec) {
2191
+ this.children_.push(suiteOrSpec);
2192
+ if (suiteOrSpec instanceof jasmine.Suite) {
2193
+ this.suites_.push(suiteOrSpec);
2194
+ this.env.currentRunner().addSuite(suiteOrSpec);
2195
+ } else {
2196
+ this.specs_.push(suiteOrSpec);
2197
+ }
2198
+ this.queue.add(suiteOrSpec);
2199
+ };
2200
+
2201
+ jasmine.Suite.prototype.specs = function() {
2202
+ return this.specs_;
2203
+ };
2204
+
2205
+ jasmine.Suite.prototype.suites = function() {
2206
+ return this.suites_;
2207
+ };
2208
+
2209
+ jasmine.Suite.prototype.children = function() {
2210
+ return this.children_;
2211
+ };
2212
+
2213
+ jasmine.Suite.prototype.execute = function(onComplete) {
2214
+ var self = this;
2215
+ this.queue.start(function () {
2216
+ self.finish(onComplete);
2217
+ });
2218
+ };
2219
+ jasmine.WaitsBlock = function(env, timeout, spec) {
2220
+ this.timeout = timeout;
2221
+ jasmine.Block.call(this, env, null, spec);
2222
+ };
2223
+
2224
+ jasmine.util.inherit(jasmine.WaitsBlock, jasmine.Block);
2225
+
2226
+ jasmine.WaitsBlock.prototype.execute = function (onComplete) {
2227
+ if (jasmine.VERBOSE) {
2228
+ this.env.reporter.log('>> Jasmine waiting for ' + this.timeout + ' ms...');
2229
+ }
2230
+ this.env.setTimeout(function () {
2231
+ onComplete();
2232
+ }, this.timeout);
2233
+ };
2234
+ /**
2235
+ * A block which waits for some condition to become true, with timeout.
2236
+ *
2237
+ * @constructor
2238
+ * @extends jasmine.Block
2239
+ * @param {jasmine.Env} env The Jasmine environment.
2240
+ * @param {Number} timeout The maximum time in milliseconds to wait for the condition to become true.
2241
+ * @param {Function} latchFunction A function which returns true when the desired condition has been met.
2242
+ * @param {String} message The message to display if the desired condition hasn't been met within the given time period.
2243
+ * @param {jasmine.Spec} spec The Jasmine spec.
2244
+ */
2245
+ jasmine.WaitsForBlock = function(env, timeout, latchFunction, message, spec) {
2246
+ this.timeout = timeout || env.defaultTimeoutInterval;
2247
+ this.latchFunction = latchFunction;
2248
+ this.message = message;
2249
+ this.totalTimeSpentWaitingForLatch = 0;
2250
+ jasmine.Block.call(this, env, null, spec);
2251
+ };
2252
+ jasmine.util.inherit(jasmine.WaitsForBlock, jasmine.Block);
2253
+
2254
+ jasmine.WaitsForBlock.TIMEOUT_INCREMENT = 10;
2255
+
2256
+ jasmine.WaitsForBlock.prototype.execute = function(onComplete) {
2257
+ if (jasmine.VERBOSE) {
2258
+ this.env.reporter.log('>> Jasmine waiting for ' + (this.message || 'something to happen'));
2259
+ }
2260
+ var latchFunctionResult;
2261
+ try {
2262
+ latchFunctionResult = this.latchFunction.apply(this.spec);
2263
+ } catch (e) {
2264
+ this.spec.fail(e);
2265
+ onComplete();
2266
+ return;
2267
+ }
2268
+
2269
+ if (latchFunctionResult) {
2270
+ onComplete();
2271
+ } else if (this.totalTimeSpentWaitingForLatch >= this.timeout) {
2272
+ var message = 'timed out after ' + this.timeout + ' msec waiting for ' + (this.message || 'something to happen');
2273
+ this.spec.fail({
2274
+ name: 'timeout',
2275
+ message: message
2276
+ });
2277
+
2278
+ this.abort = true;
2279
+ onComplete();
2280
+ } else {
2281
+ this.totalTimeSpentWaitingForLatch += jasmine.WaitsForBlock.TIMEOUT_INCREMENT;
2282
+ var self = this;
2283
+ this.env.setTimeout(function() {
2284
+ self.execute(onComplete);
2285
+ }, jasmine.WaitsForBlock.TIMEOUT_INCREMENT);
2286
+ }
2287
+ };
2288
+ // Mock setTimeout, clearTimeout
2289
+ // Contributed by Pivotal Computer Systems, www.pivotalsf.com
2290
+
2291
+ jasmine.FakeTimer = function() {
2292
+ this.reset();
2293
+
2294
+ var self = this;
2295
+ self.setTimeout = function(funcToCall, millis) {
2296
+ self.timeoutsMade++;
2297
+ self.scheduleFunction(self.timeoutsMade, funcToCall, millis, false);
2298
+ return self.timeoutsMade;
2299
+ };
2300
+
2301
+ self.setInterval = function(funcToCall, millis) {
2302
+ self.timeoutsMade++;
2303
+ self.scheduleFunction(self.timeoutsMade, funcToCall, millis, true);
2304
+ return self.timeoutsMade;
2305
+ };
2306
+
2307
+ self.clearTimeout = function(timeoutKey) {
2308
+ self.scheduledFunctions[timeoutKey] = jasmine.undefined;
2309
+ };
2310
+
2311
+ self.clearInterval = function(timeoutKey) {
2312
+ self.scheduledFunctions[timeoutKey] = jasmine.undefined;
2313
+ };
2314
+
2315
+ };
2316
+
2317
+ jasmine.FakeTimer.prototype.reset = function() {
2318
+ this.timeoutsMade = 0;
2319
+ this.scheduledFunctions = {};
2320
+ this.nowMillis = 0;
2321
+ };
2322
+
2323
+ jasmine.FakeTimer.prototype.tick = function(millis) {
2324
+ var oldMillis = this.nowMillis;
2325
+ var newMillis = oldMillis + millis;
2326
+ this.runFunctionsWithinRange(oldMillis, newMillis);
2327
+ this.nowMillis = newMillis;
2328
+ };
2329
+
2330
+ jasmine.FakeTimer.prototype.runFunctionsWithinRange = function(oldMillis, nowMillis) {
2331
+ var scheduledFunc;
2332
+ var funcsToRun = [];
2333
+ for (var timeoutKey in this.scheduledFunctions) {
2334
+ scheduledFunc = this.scheduledFunctions[timeoutKey];
2335
+ if (scheduledFunc != jasmine.undefined &&
2336
+ scheduledFunc.runAtMillis >= oldMillis &&
2337
+ scheduledFunc.runAtMillis <= nowMillis) {
2338
+ funcsToRun.push(scheduledFunc);
2339
+ this.scheduledFunctions[timeoutKey] = jasmine.undefined;
2340
+ }
2341
+ }
2342
+
2343
+ if (funcsToRun.length > 0) {
2344
+ funcsToRun.sort(function(a, b) {
2345
+ return a.runAtMillis - b.runAtMillis;
2346
+ });
2347
+ for (var i = 0; i < funcsToRun.length; ++i) {
2348
+ try {
2349
+ var funcToRun = funcsToRun[i];
2350
+ this.nowMillis = funcToRun.runAtMillis;
2351
+ funcToRun.funcToCall();
2352
+ if (funcToRun.recurring) {
2353
+ this.scheduleFunction(funcToRun.timeoutKey,
2354
+ funcToRun.funcToCall,
2355
+ funcToRun.millis,
2356
+ true);
2357
+ }
2358
+ } catch(e) {
2359
+ }
2360
+ }
2361
+ this.runFunctionsWithinRange(oldMillis, nowMillis);
2362
+ }
2363
+ };
2364
+
2365
+ jasmine.FakeTimer.prototype.scheduleFunction = function(timeoutKey, funcToCall, millis, recurring) {
2366
+ this.scheduledFunctions[timeoutKey] = {
2367
+ runAtMillis: this.nowMillis + millis,
2368
+ funcToCall: funcToCall,
2369
+ recurring: recurring,
2370
+ timeoutKey: timeoutKey,
2371
+ millis: millis
2372
+ };
2373
+ };
2374
+
2375
+ /**
2376
+ * @namespace
2377
+ */
2378
+ jasmine.Clock = {
2379
+ defaultFakeTimer: new jasmine.FakeTimer(),
2380
+
2381
+ reset: function() {
2382
+ jasmine.Clock.assertInstalled();
2383
+ jasmine.Clock.defaultFakeTimer.reset();
2384
+ },
2385
+
2386
+ tick: function(millis) {
2387
+ jasmine.Clock.assertInstalled();
2388
+ jasmine.Clock.defaultFakeTimer.tick(millis);
2389
+ },
2390
+
2391
+ runFunctionsWithinRange: function(oldMillis, nowMillis) {
2392
+ jasmine.Clock.defaultFakeTimer.runFunctionsWithinRange(oldMillis, nowMillis);
2393
+ },
2394
+
2395
+ scheduleFunction: function(timeoutKey, funcToCall, millis, recurring) {
2396
+ jasmine.Clock.defaultFakeTimer.scheduleFunction(timeoutKey, funcToCall, millis, recurring);
2397
+ },
2398
+
2399
+ useMock: function() {
2400
+ if (!jasmine.Clock.isInstalled()) {
2401
+ var spec = jasmine.getEnv().currentSpec;
2402
+ spec.after(jasmine.Clock.uninstallMock);
2403
+
2404
+ jasmine.Clock.installMock();
2405
+ }
2406
+ },
2407
+
2408
+ installMock: function() {
2409
+ jasmine.Clock.installed = jasmine.Clock.defaultFakeTimer;
2410
+ },
2411
+
2412
+ uninstallMock: function() {
2413
+ jasmine.Clock.assertInstalled();
2414
+ jasmine.Clock.installed = jasmine.Clock.real;
2415
+ },
2416
+
2417
+ real: {
2418
+ setTimeout: jasmine.getGlobal().setTimeout,
2419
+ clearTimeout: jasmine.getGlobal().clearTimeout,
2420
+ setInterval: jasmine.getGlobal().setInterval,
2421
+ clearInterval: jasmine.getGlobal().clearInterval
2422
+ },
2423
+
2424
+ assertInstalled: function() {
2425
+ if (!jasmine.Clock.isInstalled()) {
2426
+ throw new Error("Mock clock is not installed, use jasmine.Clock.useMock()");
2427
+ }
2428
+ },
2429
+
2430
+ isInstalled: function() {
2431
+ return jasmine.Clock.installed == jasmine.Clock.defaultFakeTimer;
2432
+ },
2433
+
2434
+ installed: null
2435
+ };
2436
+ jasmine.Clock.installed = jasmine.Clock.real;
2437
+
2438
+ //else for IE support
2439
+ jasmine.getGlobal().setTimeout = function(funcToCall, millis) {
2440
+ if (jasmine.Clock.installed.setTimeout.apply) {
2441
+ return jasmine.Clock.installed.setTimeout.apply(this, arguments);
2442
+ } else {
2443
+ return jasmine.Clock.installed.setTimeout(funcToCall, millis);
2444
+ }
2445
+ };
2446
+
2447
+ jasmine.getGlobal().setInterval = function(funcToCall, millis) {
2448
+ if (jasmine.Clock.installed.setInterval.apply) {
2449
+ return jasmine.Clock.installed.setInterval.apply(this, arguments);
2450
+ } else {
2451
+ return jasmine.Clock.installed.setInterval(funcToCall, millis);
2452
+ }
2453
+ };
2454
+
2455
+ jasmine.getGlobal().clearTimeout = function(timeoutKey) {
2456
+ if (jasmine.Clock.installed.clearTimeout.apply) {
2457
+ return jasmine.Clock.installed.clearTimeout.apply(this, arguments);
2458
+ } else {
2459
+ return jasmine.Clock.installed.clearTimeout(timeoutKey);
2460
+ }
2461
+ };
2462
+
2463
+ jasmine.getGlobal().clearInterval = function(timeoutKey) {
2464
+ if (jasmine.Clock.installed.clearTimeout.apply) {
2465
+ return jasmine.Clock.installed.clearInterval.apply(this, arguments);
2466
+ } else {
2467
+ return jasmine.Clock.installed.clearInterval(timeoutKey);
2468
+ }
2469
+ };
2470
+
2471
+ jasmine.version_= {
2472
+ "major": 1,
2473
+ "minor": 1,
2474
+ "build": 0,
2475
+ "revision": 1308965645,
2476
+ "release_candidate": 2
2477
+ };