Home page Forum Wiki Mail Jabber Devel NIX-FILES

AltLUG Git

Git-repositories of Altai Linux User Group

7f5d785c0dd03e594a4f9ed08067ceb388ac2f90
[qunit.git] / test / test.js
1 test("module without setup/teardown (default)", function() {
2         expect(1);
3         ok(true);
4 });
5
6 test("expect in test", 3, function() {
7         ok(true);
8         ok(true);
9         ok(true);
10 });
11
12 test("expect in test", 1, function() {
13         ok(true);
14 });
15
16 test("expect query and multiple issue", function() {
17         expect(2);
18         ok(true);
19         var expected = expect();
20         equal(expected, 2);
21         expect(expected + 1);
22         ok(true);
23 });
24
25 QUnit.module("assertion helpers");
26
27 QUnit.test( "QUnit.assert compatibility", function( assert ) {
28         QUnit.expect(4);
29
30         assert.ok( true, "Calling method on `assert` argument to test() callback" );
31
32         // Should also work, although not documented
33         QUnit.assert.ok( true, "Calling method on QUnit.assert object" );
34
35         // Test compatibility aliases
36         QUnit.ok( true, "Calling aliased method in QUnit root object" );
37         ok( true, "Calling aliased function in global namespace" );
38 });
39
40 module("setup test", {
41         setup: function() {
42                 ok(true);
43         }
44 });
45
46 test("module with setup", function() {
47         expect(2);
48         ok(true);
49 });
50
51 test("module with setup, expect in test call", 2, function() {
52         ok(true);
53 });
54
55 var state;
56
57 module("setup/teardown test", {
58         setup: function() {
59                 state = true;
60                 ok(true);
61                 x = 1;
62         },
63         teardown: function() {
64                 ok(true);
65                 // can introduce and delete globals in setup/teardown
66                 // without noglobals sounding the alarm
67                 delete x;
68         }
69 });
70
71 test("module with setup/teardown", function() {
72         expect(3);
73         ok(true);
74 });
75
76 module("setup/teardown test 2");
77
78 test("module without setup/teardown", function() {
79         expect(1);
80         ok(true);
81 });
82
83
84
85 var orgDate;
86
87 module("Date test", {
88         setup: function() {
89                 orgDate = Date;
90                 Date = function () {
91                         ok( false, 'QUnit should internally be independant from Date-related manipulation and testing' );
92                         return new orgDate();
93                 };
94         },
95         teardown: function() {
96                 Date = orgDate;
97         }
98 });
99
100 test("sample test for Date test", function () {
101         expect(1);
102         ok(true);
103 });
104
105 if (typeof setTimeout !== 'undefined') {
106 state = 'fail';
107
108 module("teardown and stop", {
109         teardown: function() {
110                 equal(state, "done", "Test teardown.");
111         }
112 });
113
114 test("teardown must be called after test ended", function() {
115         expect(1);
116         stop();
117         setTimeout(function() {
118                 state = "done";
119                 start();
120         }, 13);
121 });
122
123 test("parameter passed to stop increments semaphore n times", function() {
124         expect(1);
125         stop(3);
126         setTimeout(function() {
127                 state = "not enough starts";
128                 start(), start();
129         }, 13);
130         setTimeout(function() {
131                 state = "done";
132                 start();
133         }, 15);
134 });
135
136 test("parameter passed to start decrements semaphore n times", function() {
137         expect(1);
138         stop(), stop(), stop();
139         setTimeout(function() {
140                 state = "done";
141                 start(3);
142         }, 18);
143 });
144
145 module("async setup test", {
146         setup: function() {
147                 stop();
148                 setTimeout(function(){
149                         ok(true);
150                         start();
151                 }, 500);
152         }
153 });
154
155 asyncTest("module with async setup", function() {
156         expect(2);
157         ok(true);
158         start();
159 });
160
161 module("async teardown test", {
162         teardown: function() {
163                 stop();
164                 setTimeout(function(){
165                         ok(true);
166                         start();
167                 }, 500);
168         }
169 });
170
171 asyncTest("module with async teardown", function() {
172         expect(2);
173         ok(true);
174         start();
175 });
176
177 module("asyncTest");
178
179 asyncTest("asyncTest", function() {
180         expect(2);
181         ok(true);
182         setTimeout(function() {
183                 state = "done";
184                 ok(true);
185                 start();
186         }, 13);
187 });
188
189 asyncTest("asyncTest", 2, function() {
190         ok(true);
191         setTimeout(function() {
192                 state = "done";
193                 ok(true);
194                 start();
195         }, 13);
196 });
197
198 test("sync", 2, function() {
199         stop();
200         setTimeout(function() {
201                 ok(true);
202                 start();
203         }, 13);
204         stop();
205         setTimeout(function() {
206                 ok(true);
207                 start();
208         }, 125);
209 });
210
211 test("test synchronous calls to stop", 2, function() {
212         stop();
213         setTimeout(function(){
214                 ok(true, 'first');
215                 start();
216                 stop();
217                 setTimeout(function(){
218                         ok(true, 'second');
219                         start();
220                 }, 150);
221         }, 150);
222 });
223 }
224
225 module("save scope", {
226         setup: function() {
227                 this.foo = "bar";
228         },
229         teardown: function() {
230                 deepEqual(this.foo, "bar");
231         }
232 });
233 test("scope check", function() {
234         expect(2);
235         deepEqual(this.foo, "bar");
236 });
237
238 module("simple testEnvironment setup", {
239         foo: "bar",
240         bugid: "#5311" // example of meta-data
241 });
242 test("scope check", function() {
243         deepEqual(this.foo, "bar");
244 });
245 test("modify testEnvironment",function() {
246         expect(0);
247         this.foo="hamster";
248 });
249 test("testEnvironment reset for next test",function() {
250         deepEqual(this.foo, "bar");
251 });
252
253 module("testEnvironment with object", {
254         options:{
255                 recipe:"soup",
256                 ingredients:["hamster","onions"]
257         }
258 });
259 test("scope check", function() {
260         deepEqual(this.options, {recipe:"soup",ingredients:["hamster","onions"]}) ;
261 });
262 test("modify testEnvironment",function() {
263         expect(0);
264         // since we do a shallow copy, the testEnvironment can be modified
265         this.options.ingredients.push("carrots");
266 });
267 test("testEnvironment reset for next test",function() {
268         deepEqual(this.options, {recipe:"soup",ingredients:["hamster","onions","carrots"]}, "Is this a bug or a feature? Could do a deep copy") ;
269 });
270
271
272 module("testEnvironment tests");
273
274 function makeurl() {
275         var testEnv = QUnit.current_testEnvironment;
276         var url = testEnv.url || 'http://example.com/search';
277         var q   = testEnv.q   || 'a search test';
278         return url + '?q='+encodeURIComponent(q);
279 }
280
281 test("makeurl working",function() {
282         equal( QUnit.current_testEnvironment, this, 'The current testEnvironment is global');
283         equal( makeurl(), 'http://example.com/search?q=a%20search%20test', 'makeurl returns a default url if nothing specified in the testEnvironment');
284 });
285
286 module("testEnvironment with makeurl settings", {
287         url: 'http://google.com/',
288         q: 'another_search_test'
289 });
290 test("makeurl working with settings from testEnvironment", function() {
291         equal( makeurl(), 'http://google.com/?q=another_search_test', 'rather than passing arguments, we use test metadata to from the url');
292 });
293
294 module("jsDump");
295 test("jsDump output", function() {
296         equal( QUnit.jsDump.parse([1, 2]), "[\n  1,\n  2\n]" );
297         equal( QUnit.jsDump.parse({top: 5, left: 0}), "{\n  \"left\": 0,\n  \"top\": 5\n}" );
298         if (typeof document !== 'undefined' && document.getElementById("qunit-header")) {
299                 equal( QUnit.jsDump.parse(document.getElementById("qunit-header")), "<h1 id=\"qunit-header\"></h1>" );
300                 equal( QUnit.jsDump.parse(document.getElementsByTagName("h1")), "[\n  <h1 id=\"qunit-header\"></h1>\n]" );
301         }
302 });
303
304 module("assertions");
305 test("raises",function() {
306         function CustomError( message ) {
307                 this.message = message;
308         }
309
310         CustomError.prototype.toString = function() {
311                 return this.message;
312         };
313
314         throws(
315                 function() {
316                         throw "my error"
317                 }
318         );
319
320         throws(
321                 function() {
322                         throw "my error"
323                 },
324                 "simple string throw, no 'expected' value given"
325         );
326
327         throws(
328                 function() {
329                         throw new CustomError();
330                 },
331                 CustomError,
332                 'thrown error is an instance of CustomError'
333         );
334
335         throws(
336                 function() {
337                         throw new CustomError("some error description");
338                 },
339                 /description/,
340                 "use a regex to match against the stringified error"
341         );
342
343         throws(
344                 function() {
345                         throw new CustomError("some error description");
346                 },
347                 function( err ) {
348                         if ( (err instanceof CustomError) && /description/.test(err) ) {
349                                 return true;
350                         }
351                 },
352                 "custom validation function"
353         );
354
355         throws(
356                 function() {
357                         ( window.execScript || function( data ) {
358                                 window["eval"].call( window, data );
359                         })( "throw 'error'" );
360                 },
361                 'globally-executed errors caught'
362         );
363
364     this.CustomError = CustomError;
365
366     throws(
367         function() {
368             throw new this.CustomError("some error description");
369         },
370         /description/,
371         "throw error from property of 'this' context"
372     );
373
374     raises(
375         function() {
376             throw "error"
377         },
378         "simple throw, asserting with deprecated raises() function"
379     );
380
381 });
382
383 if (typeof document !== "undefined") {
384
385 module("fixture");
386 test("setup", function() {
387         expect(0);
388         document.getElementById("qunit-fixture").innerHTML = "foobar";
389 });
390 test("basics", function() {
391         equal( document.getElementById("qunit-fixture").innerHTML, "test markup", "automatically reset" );
392 });
393
394 test("running test name displayed", function() {
395         expect(2);
396
397         var displaying = document.getElementById("qunit-testresult");
398
399         ok( /running test name displayed/.test(displaying.innerHTML), "Expect test name to be found in displayed text" );
400         ok( /fixture/.test(displaying.innerHTML), "Expect module name to be found in displayed text" );
401 });
402
403 }
404
405 module("custom assertions");
406 (function() {
407         function mod2(value, expected, message) {
408                 var actual = value % 2;
409                 QUnit.push(actual == expected, actual, expected, message);
410         }
411         test("mod2", function() {
412                 mod2(2, 0, "2 % 2 == 0");
413                 mod2(3, 1, "3 % 2 == 1");
414         });
415 })();
416
417
418 module("recursions");
419
420 function Wrap(x) {
421         this.wrap = x;
422         if (x == undefined)  this.first = true;
423 }
424
425 function chainwrap(depth, first, prev) {
426         depth = depth || 0;
427         var last = prev || new Wrap();
428         first = first || last;
429
430         if (depth == 1) {
431                 first.wrap = last;
432         }
433         if (depth > 1) {
434                 last = chainwrap(depth-1, first, new Wrap(last));
435         }
436
437         return last;
438 }
439
440 test("check jsDump recursion", function() {
441         expect(4);
442
443         var noref = chainwrap(0);
444         var nodump = QUnit.jsDump.parse(noref);
445         equal(nodump, '{\n  "first": true,\n  "wrap": undefined\n}');
446
447         var selfref = chainwrap(1);
448         var selfdump = QUnit.jsDump.parse(selfref);
449         equal(selfdump, '{\n  "first": true,\n  "wrap": recursion(-1)\n}');
450
451         var parentref = chainwrap(2);
452         var parentdump = QUnit.jsDump.parse(parentref);
453         equal(parentdump, '{\n  "wrap": {\n    "first": true,\n    "wrap": recursion(-2)\n  }\n}');
454
455         var circref = chainwrap(10);
456         var circdump = QUnit.jsDump.parse(circref);
457         ok(new RegExp("recursion\\(-10\\)").test(circdump), "(" +circdump + ") should show -10 recursion level");
458 });
459
460 test("check (deep-)equal recursion", function() {
461         var noRecursion = chainwrap(0);
462         equal(noRecursion, noRecursion, "I should be equal to me.");
463         deepEqual(noRecursion, noRecursion, "... and so in depth.");
464
465         var selfref = chainwrap(1);
466         equal(selfref, selfref, "Even so if I nest myself.");
467         deepEqual(selfref, selfref, "... into the depth.");
468
469         var circref = chainwrap(10);
470         equal(circref, circref, "Or hide that through some levels of indirection.");
471         deepEqual(circref, circref, "... and checked on all levels!");
472 });
473
474
475 test('Circular reference with arrays', function() {
476
477         // pure array self-ref
478         var arr = [];
479         arr.push(arr);
480
481         var arrdump = QUnit.jsDump.parse(arr);
482
483         equal(arrdump, '[\n  recursion(-1)\n]');
484         equal(arr, arr[0], 'no endless stack when trying to dump arrays with circular ref');
485
486
487         // mix obj-arr circular ref
488         var obj = {};
489         var childarr = [obj];
490         obj.childarr = childarr;
491
492         var objdump = QUnit.jsDump.parse(obj);
493         var childarrdump = QUnit.jsDump.parse(childarr);
494
495         equal(objdump, '{\n  "childarr": [\n    recursion(-2)\n  ]\n}');
496         equal(childarrdump, '[\n  {\n    "childarr": recursion(-2)\n  }\n]');
497
498         equal(obj.childarr, childarr, 'no endless stack when trying to dump array/object mix with circular ref');
499         equal(childarr[0], obj, 'no endless stack when trying to dump array/object mix with circular ref');
500
501 });
502
503
504 test('Circular reference - test reported by soniciq in #105', function() {
505         var MyObject = function() {};
506         MyObject.prototype.parent = function(obj) {
507                 if (obj === undefined) { return this._parent; }
508                 this._parent = obj;
509         };
510         MyObject.prototype.children = function(obj) {
511                 if (obj === undefined) { return this._children; }
512                 this._children = obj;
513         };
514
515         var a = new MyObject(),
516                 b = new MyObject();
517
518         var barr = [b];
519         a.children(barr);
520         b.parent(a);
521
522         equal(a.children(), barr);
523         deepEqual(a.children(), [b]);
524 });
525
526 (function() {
527         var reset = QUnit.reset;
528         module("reset");
529         test("reset runs assertions", function() {
530                 expect(0);
531                 QUnit.reset = function() {
532                         ok( false, "reset should not modify test status" );
533                         reset.apply( this, arguments );
534                 };
535         });
536         test("reset runs assertions, cleanup", function() {
537                 expect(0);
538                 QUnit.reset = reset;
539         });
540 })();
541
542 if (typeof setTimeout !== 'undefined') {
543 function testAfterDone(){
544         var testName = "ensure has correct number of assertions";
545
546         function secondAfterDoneTest(){
547                 QUnit.config.done = [];
548                 //QUnit.done = function(){};
549                 //because when this does happen, the assertion count parameter doesn't actually
550                 //work we use this test to check the assertion count.
551                 module("check previous test's assertion counts");
552                 test('count previous two test\'s assertions', function(){
553                         var spans = document.getElementsByTagName('span'),
554                         tests = [],
555                         countNodes;
556
557                         //find these two tests
558                         for (var i = 0; i < spans.length; i++) {
559                                 if (spans[i].innerHTML.indexOf(testName) !== -1) {
560                                         tests.push(spans[i]);
561                                 }
562                         }
563
564                         //walk dom to counts
565                         countNodes = tests[0].nextSibling.nextSibling.getElementsByTagName('b');
566                         equal(countNodes[1].innerHTML, "99");
567                         countNodes = tests[1].nextSibling.nextSibling.getElementsByTagName('b');
568                         equal(countNodes[1].innerHTML, "99");
569                 });
570         }
571         QUnit.config.done = [];
572         QUnit.done(secondAfterDoneTest);
573
574         module("Synchronous test after load of page");
575
576         asyncTest('Async test', function(){
577                 start();
578                 for (var i = 1; i < 100; i++) {
579                         ok(i);
580                 }
581         });
582
583         test(testName, 99, function(){
584                 for (var i = 1; i < 100; i++) {
585                         ok(i);
586                 }
587         });
588
589         //we need two of these types of tests in order to ensure that assertions
590         //don't move between tests.
591         test(testName + ' 2', 99, function(){
592                 for (var i = 1; i < 100; i++) {
593                         ok(i);
594                 }
595         });
596
597
598 }
599
600 QUnit.done(testAfterDone);
601
602 }

Hosting is provided AltSPAHow to use Git
Please direct any questions on jabber alex.wolf@jabber.ru

Valid HTML 4.0 Transitional Valid CSS!

Designer Alexander Wolf