Home page Forum Wiki Mail Jabber Devel NIX-FILES

AltLUG Git

Git-repositories of Altai Linux User Group

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

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