Home page Forum Wiki Mail Jabber Devel NIX-FILES

AltLUG Git

Git-repositories of Altai Linux User Group

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

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