| parameter | 52 |value | 53 |
|---|---|
| domTime | 56 |The time the browser spends on evaluating the loaded document (DOM calculation, Asset fetching) until dom:ready | 57 |
| networkTime | 60 |The time thats being spent only to fetch the whole document excluding assets. | 61 |
| dnsTime | 64 |Time being spend resolving the hostname | 65 |
| complete | 68 |The complete time from initiating the pageload until dom:ready. Including dom:ready relevant asset requests | 69 |
| clickObject | 72 |A nice insight of minor importance: where did the user click on the loaded page. Could it be, that your users constantly click your exit button on a special page because it peforms bad ? | 73 |
| timeToFirstClick | 76 |Another new metric: When (counting from the triggering the pageload) does the user perform the first click. Could lead to some interesting performance insights | 77 |
| timeFromMoveToClick | 80 |Delivers the time difference from the first movement of the mouse until the first click. Question could be: "Do your users move the mouse around for hours until they click due to bad performance ?" | 81 |
| parentURL | 84 |The URL where the user was at time of the monitoring | 85 |
| referrer | 88 |The URL before this page | 89 |
| htmlLength | 92 |The number of characters inside the body at the moment of the first click in the document. A good metric to learn about your avg pagesizse. | 93 |
| numberStylesheets | 96 |The number of Stylesheets being loaded from this page. Two is a good number, more than 5 far too much. | 97 |
| pageViewsUntilCheckout | 100 |The number of pageviews a user performs until he buys something on your site. Indicator is when he arrives at URL_PATTERN_FOR_CHECKOUT_PAGE . Afterwards the counter here is resetted. | 101 |
| clicksUntilCheckout | 104 |The number of click a user performs until he buys something on your site. Indicator is when he arrives at URL_PATTERN_FOR_CHECKOUT_PAGE . Afterwards the counter here is resetted. Can give some insights to your UX on how click intensively your website is (JIRA or Typo3 should have awesome high numbers here). | 105 |
| parameter | 113 |value | 114 |
|---|---|
| Just an integer 1. You need to sum them up get the overall printouts per time period. | 118 |
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 '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 |
--------------------------------------------------------------------------------