Home page Forum Wiki Mail Jabber Devel NIX-FILES

AltLUG Git

Git-repositories of Altai Linux User Group

Mini lint commit
[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                 window.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 window.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         // example of meta-data
241         bugid: "#5311"
242 });
243 test("scope check", function() {
244         deepEqual(this.foo, "bar");
245 });
246 test("modify testEnvironment",function() {
247         expect(0);
248         this.foo="hamster";
249 });
250 test("testEnvironment reset for next test",function() {
251         deepEqual(this.foo, "bar");
252 });
253
254 module("testEnvironment with object", {
255         options:{
256                 recipe:"soup",
257                 ingredients:["hamster","onions"]
258         }
259 });
260 test("scope check", function() {
261         deepEqual(this.options, {recipe:"soup",ingredients:["hamster","onions"]}) ;
262 });
263 test("modify testEnvironment",function() {
264         expect(0);
265         // since we do a shallow copy, the testEnvironment can be modified
266         this.options.ingredients.push("carrots");
267 });
268 test("testEnvironment reset for next test",function() {
269         deepEqual(this.options, {recipe:"soup",ingredients:["hamster","onions","carrots"]}, "Is this a bug or a feature? Could do a deep copy") ;
270 });
271
272
273 module("testEnvironment tests");
274
275 function makeurl() {
276         var testEnv = QUnit.current_testEnvironment;
277         var url = testEnv.url || 'http://example.com/search';
278         var q   = testEnv.q   || 'a search test';
279         return url + '?q='+encodeURIComponent(q);
280 }
281
282 test("makeurl working",function() {
283         equal( QUnit.current_testEnvironment, this, 'The current testEnvironment is global');
284         equal( makeurl(), 'http://example.com/search?q=a%20search%20test', 'makeurl returns a default url if nothing specified in the testEnvironment');
285 });
286
287 module("testEnvironment with makeurl settings", {
288         url: 'http://google.com/',
289         q: 'another_search_test'
290 });
291 test("makeurl working with settings from testEnvironment", function() {
292         equal( makeurl(), 'http://google.com/?q=another_search_test', 'rather than passing arguments, we use test metadata to from the url');
293 });
294
295 module("jsDump");
296 test("jsDump output", function() {
297         equal( QUnit.jsDump.parse([1, 2]), "[\n  1,\n  2\n]" );
298         equal( QUnit.jsDump.parse({top: 5, left: 0}), "{\n  \"left\": 0,\n  \"top\": 5\n}" );
299         if (typeof document !== 'undefined' && document.getElementById("qunit-header")) {
300                 equal( QUnit.jsDump.parse(document.getElementById("qunit-header")), "<h1 id=\"qunit-header\"></h1>" );
301                 equal( QUnit.jsDump.parse(document.getElementsByTagName("h1")), "[\n  <h1 id=\"qunit-header\"></h1>\n]" );
302         }
303 });
304
305 module("assertions");
306 test("raises",function() {
307         function CustomError( message ) {
308                 this.message = message;
309         }
310
311         CustomError.prototype.toString = function() {
312                 return this.message;
313         };
314
315         throws(
316                 function() {
317                         throw "my error";
318                 }
319         );
320
321         throws(
322                 function() {
323                         throw "my error";
324                 },
325                 "simple string throw, no 'expected' value given"
326         );
327
328         throws(
329                 function() {
330                         throw new CustomError();
331                 },
332                 CustomError,
333                 'thrown error is an instance of CustomError'
334         );
335
336         throws(
337                 function() {
338                         throw new CustomError("some error description");
339                 },
340                 /description/,
341                 "use a regex to match against the stringified error"
342         );
343
344         throws(
345                 function() {
346                         throw new CustomError("some error description");
347                 },
348                 function( err ) {
349                         if ( (err instanceof CustomError) && /description/.test(err) ) {
350                                 return true;
351                         }
352                 },
353                 "custom validation function"
354         );
355
356         throws(
357                 function() {
358                         /*jshint evil:true */
359                         ( window.execScript || function( data ) {
360                                 window["eval"].call( window, data );
361                         })( "throw 'error';" );
362                 },
363                 'globally-executed errors caught'
364         );
365
366     this.CustomError = CustomError;
367
368     throws(
369         function() {
370             throw new this.CustomError("some error description");
371         },
372         /description/,
373         "throw error from property of 'this' context"
374     );
375
376     raises(
377         function() {
378             throw "error";
379         },
380         "simple throw, asserting with deprecated raises() function"
381     );
382
383 });
384
385 if (typeof document !== "undefined") {
386
387 module("fixture");
388 test("setup", function() {
389         expect(0);
390         document.getElementById("qunit-fixture").innerHTML = "foobar";
391 });
392 test("basics", function() {
393         equal( document.getElementById("qunit-fixture").innerHTML, "test markup", "automatically reset" );
394 });
395
396 test("running test name displayed", function() {
397         expect(2);
398
399         var displaying = document.getElementById("qunit-testresult");
400
401         ok( /running test name displayed/.test(displaying.innerHTML), "Expect test name to be found in displayed text" );
402         ok( /fixture/.test(displaying.innerHTML), "Expect module name to be found in displayed text" );
403 });
404
405 }
406
407 module("custom assertions");
408 (function() {
409         function mod2(value, expected, message) {
410                 var actual = value % 2;
411                 QUnit.push(actual == expected, actual, expected, message);
412         }
413         test("mod2", function() {
414                 mod2(2, 0, "2 % 2 == 0");
415                 mod2(3, 1, "3 % 2 == 1");
416         });
417 })();
418
419
420 module("recursions");
421
422 function Wrap(x) {
423         this.wrap = x;
424         if (x === undefined) {
425                 this.first = true;
426         }
427 }
428
429 function chainwrap(depth, first, prev) {
430         depth = depth || 0;
431         var last = prev || new Wrap();
432         first = first || last;
433
434         if (depth == 1) {
435                 first.wrap = last;
436         }
437         if (depth > 1) {
438                 last = chainwrap(depth-1, first, new Wrap(last));
439         }
440
441         return last;
442 }
443
444 test("check jsDump recursion", function() {
445         expect(4);
446
447         var noref = chainwrap(0);
448         var nodump = QUnit.jsDump.parse(noref);
449         equal(nodump, '{\n  "first": true,\n  "wrap": undefined\n}');
450
451         var selfref = chainwrap(1);
452         var selfdump = QUnit.jsDump.parse(selfref);
453         equal(selfdump, '{\n  "first": true,\n  "wrap": recursion(-1)\n}');
454
455         var parentref = chainwrap(2);
456         var parentdump = QUnit.jsDump.parse(parentref);
457         equal(parentdump, '{\n  "wrap": {\n    "first": true,\n    "wrap": recursion(-2)\n  }\n}');
458
459         var circref = chainwrap(10);
460         var circdump = QUnit.jsDump.parse(circref);
461         ok(new RegExp("recursion\\(-10\\)").test(circdump), "(" +circdump + ") should show -10 recursion level");
462 });
463
464 test("check (deep-)equal recursion", function() {
465         var noRecursion = chainwrap(0);
466         equal(noRecursion, noRecursion, "I should be equal to me.");
467         deepEqual(noRecursion, noRecursion, "... and so in depth.");
468
469         var selfref = chainwrap(1);
470         equal(selfref, selfref, "Even so if I nest myself.");
471         deepEqual(selfref, selfref, "... into the depth.");
472
473         var circref = chainwrap(10);
474         equal(circref, circref, "Or hide that through some levels of indirection.");
475         deepEqual(circref, circref, "... and checked on all levels!");
476 });
477
478
479 test('Circular reference with arrays', function() {
480
481         // pure array self-ref
482         var arr = [];
483         arr.push(arr);
484
485         var arrdump = QUnit.jsDump.parse(arr);
486
487         equal(arrdump, '[\n  recursion(-1)\n]');
488         equal(arr, arr[0], 'no endless stack when trying to dump arrays with circular ref');
489
490
491         // mix obj-arr circular ref
492         var obj = {};
493         var childarr = [obj];
494         obj.childarr = childarr;
495
496         var objdump = QUnit.jsDump.parse(obj);
497         var childarrdump = QUnit.jsDump.parse(childarr);
498
499         equal(objdump, '{\n  "childarr": [\n    recursion(-2)\n  ]\n}');
500         equal(childarrdump, '[\n  {\n    "childarr": recursion(-2)\n  }\n]');
501
502         equal(obj.childarr, childarr, 'no endless stack when trying to dump array/object mix with circular ref');
503         equal(childarr[0], obj, 'no endless stack when trying to dump array/object mix with circular ref');
504
505 });
506
507
508 test('Circular reference - test reported by soniciq in #105', function() {
509         var MyObject = function() {};
510         MyObject.prototype.parent = function(obj) {
511                 if (obj === undefined) { return this._parent; }
512                 this._parent = obj;
513         };
514         MyObject.prototype.children = function(obj) {
515                 if (obj === undefined) { return this._children; }
516                 this._children = obj;
517         };
518
519         var a = new MyObject(),
520                 b = new MyObject();
521
522         var barr = [b];
523         a.children(barr);
524         b.parent(a);
525
526         equal(a.children(), barr);
527         deepEqual(a.children(), [b]);
528 });
529
530 (function() {
531         var reset = QUnit.reset;
532         module("reset");
533         test("reset runs assertions", function() {
534                 expect(0);
535                 QUnit.reset = function() {
536                         ok( false, "reset should not modify test status" );
537                         reset.apply( this, arguments );
538                 };
539         });
540         test("reset runs assertions, cleanup", function() {
541                 expect(0);
542                 QUnit.reset = reset;
543         });
544 })();
545
546 function testAfterDone() {
547         var testName = "ensure has correct number of assertions";
548
549         function secondAfterDoneTest() {
550                 QUnit.config.done = [];
551                 // Because when this does happen, the assertion count parameter doesn't actually
552                 // work we use this test to check the assertion count.
553                 module("check previous test's assertion counts");
554                 test('count previous two test\'s assertions', function () {
555                         var i, countNodes,
556                                 spans = document.getElementsByTagName('span'),
557                                 tests = [];
558
559                         // Find these two tests
560                         for (i = 0; i < spans.length; i++) {
561                                 if (spans[i].innerHTML.indexOf(testName) !== -1) {
562                                         tests.push(spans[i]);
563                                 }
564                         }
565
566                         // Walk dom to counts.
567                         countNodes = tests[0].nextSibling.nextSibling.getElementsByTagName('b');
568                         equal(countNodes[1].innerHTML, "99");
569                         countNodes = tests[1].nextSibling.nextSibling.getElementsByTagName('b');
570                         equal(countNodes[1].innerHTML, "99");
571                 });
572         }
573         QUnit.config.done = [];
574         QUnit.done(secondAfterDoneTest);
575
576         module("Synchronous test after load of page");
577
578         asyncTest('Async test', function() {
579                 start();
580                 for (var i = 1; i < 100; i++) {
581                         ok(i);
582                 }
583         });
584
585         test(testName, 99, function() {
586                 for (var i = 1; i < 100; i++) {
587                         ok(i);
588                 }
589         });
590
591         // We need two of these types of tests in order to ensure that assertions
592         // don't move between tests.
593         test(testName + ' 2', 99, function() {
594                 for (var i = 1; i < 100; i++) {
595                         ok(i);
596                 }
597         });
598
599
600 }
601
602 if (typeof setTimeout !== 'undefined') {
603         QUnit.done(testAfterDone);
604 }

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