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