The Tor Browser / file comparison

comparison: dom/base/test/test_bug715041.xul

dom/base/test/test_bug715041.xul

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:2af10125b09b
1 <?xml version="1.0"?>
2 <?xml-stylesheet type="text/css" href="chrome://global/skin"?>
3 <?xml-stylesheet type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"?>
4 <!--
5 https://bugzilla.mozilla.org/show_bug.cgi?id=715041
6 -->
7 <window title="Mozilla Bug 715041"
8 xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
9 <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/>
10
11 <!-- test results are displayed in the html:body -->
12 <body xmlns="http://www.w3.org/1999/xhtml">
13 <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=715041"
14 target="_blank">Mozilla Bug 715041</a>
15 </body>
16
17 <!-- test code goes here -->
18 <script type="application/javascript">
19 <![CDATA[
20
21 /** Mock Idle Service Test for Bug 715041 **/
22 SpecialPowers.setBoolPref("dom.idle-observers-api.fuzz_time.disabled", true);
23
24 //class mock javascript idle service
25 var idleServiceObj = {
26 observers: [],
27 windowObservers: [],
28 idleTimeInMS: 5000, //in milli seconds
29
30 // takes note of the idle observers added as the minimum idle observer
31 // with the idle service
32 timesAdded: [],
33
34 QueryInterface: function(iid) {
35 if (iid.equals(Components.interfaces.nsISupports) ||
36 iid.equals(Components.interfaces.nsIFactory) ||
37 iid.equals(Components.interfaces.nsIIdleService)) {
38 return this;
39 }
40 throw Components.results.NS_ERROR_NO_INTERFACE;
41 },
42
43 createInstance: function(outer, iid) {
44 return this.QueryInterface(iid);
45 },
46
47 get idleTime() {
48 return this.idleTimeInMS; //in milli seconds
49 },
50
51 set idleTime(timeInMS) {
52 this.idleTimeInMS = timeInMS;
53 },
54
55 getWindowFromObserver: function(observer) {
56 try {
57 var interfaceRequestor = observer.QueryInterface(Components.interfaces.nsIInterfaceRequestor);
58 var window = interfaceRequestor.getInterface(Components.interfaces.nsIDOMWindow);
59 return window;
60 }
61 catch (e) {}
62
63 return null;
64 },
65
66 testIdleBackService: function(observer, topic) {
67 dump("\nJS FAKE IDLE SERVICE\n");
68 dump("JS NUM OBSERVERS: " + this.observers.length + "\n");
69
70 if (this.observers.length > 1) {
71 this.observers[1].observer.observe(observer, topic, '\0');
72 dump("JS CALLED OBSERVE FUNCTION!!!\n\n");
73 }
74 },
75
76 addIdleObserver: function(observer, time) {
77 dump("\nJS FAKE IDLE SERVICE add idle observer before\n");
78 dump("JS NUM OBSERVERS: " + this.observers.length + "\n");
79
80 var window = this.getWindowFromObserver(observer);
81 dump("window is: " + window + "\n");
82
83 if (window) {
84 this.observers.push({ observer: observer, time: time, });
85 addedIdleObserver = true;
86 numIdleObserversAdded++;
87 this.timesAdded.push(time);
88
89 dump ("\nMOCK IDLE SERVICE ADDING idle observer with time: " + time + "\n");
90 dump("MOCK IDLE SERVICE: num idle observers added: " + numIdleObserversAdded + "\n\n");
91 }
92 else {
93 dump("SHOULD NEVER GET HERE!");
94 oldIdleService.addIdleObserver(observer, time);
95 addedIdleObserver = false;
96 }
97
98 dump("\nJS FAKE IDLE SERVICE end of add idle observer\n");
99 dump("JS NUM OBSERVERS: " + this.observers.length + "\n");
100 },
101
102 removeIdleObserver: function(observer, time) {
103 dump("\nJS REMOVE IDLE OBSERVER () time to be removed: " + time + "\n");
104 var window = this.getWindowFromObserver(observer);
105 if (!window) {
106 oldIdleService.removeIdleObserver(observer, time);
107 }
108 else {
109 var observerIndex = -1;
110 for (var i=0; i<this.observers.length; i++) {
111 dump("JS removeIdleObserver() observer time: " + this.observers[i].time + "\n");
112 if (this.observers[i].time === time) {
113 observerIndex = i;
114 break;
115 }
116 }
117
118 if (observerIndex != -1 && this.observers.length > 0) {
119 numIdleObserversRemoved++;
120 this.observers.splice(observerIndex, 1);
121 removedIdleObserver = true;
122 dump("MOCK IDLE SERVICE REMOVING idle observer with time " + time + "\n");
123 dump("MOCK IDLE SERVICE numIdleObserversRemoved: " + numIdleObserversRemoved + " numIdleObserversAdded: " + numIdleObserversAdded + "\n\n");
124 }
125 else {
126 removedIdleObserver = false;
127 }
128 }
129 dump("\nJS FAKE IDLE SERVICE end of remove idle observer\n");
130 dump("JS NUM OBSERVERS: " + this.observers.length + "\n");
131 },
132 };
133
134 /** Test for Bug 715041 **/
135 dump("\n\n\nJS STARTING TESTING FOR BUG 715041\n");
136
137 //bool variables
138 var addedIdleObserver = removedIdleObserver = passed = cleanUp = false;
139
140 //test case enabled
141 var AddOutOfOrderActiveEnabled = AddOutOfOrderIdleEnabled =
142 AddShiftLocalEnabled = AddNewLocalWhileAllIdleEnabled =
143 TestActiveToActiveNotification = ShiftLocalTimerBackEnabled =
144 AddRemoveIdleObserverWithInvalidTimeEnabled = true;
145
146 //msgXCount
147 var msg0Count = msg1Count = msg2Count = msg3Count = msg4Count = msg5Count =
148 msg6Count = tcZero = currTestCaseNum = prevMsgNum =
149 numIdleObserversRemoved = numIdleObserversAdded = 0;
150
151 //test case number
152 var tcZero = 0;
153 var tcAddOutOfOrderActive = 1;
154 var tcAddOutOfOrderIdle = 2;
155 var tcAddShiftLocal = 3;
156 var tcAddNewLocalWhileAllIdle = 4;
157 var tcShiftLocalTimerBack = 5;
158 var tcAddRemoveIdleObserverWithInvalidTime = 6;
159 var tcTestActiveToActiveNotification = 7;
160
161 function ResetMsgCounts() {
162 msg0Count = msg1Count = msg2Count = msg3Count = msg4Count = msg5Count =
163 msg6Count = prevMsgNum = 0;
164 }
165
166 function ResetVars() {
167 msg0Count = msg1Count = msg2Count = msg3Count = msg4Count = msg5Count =
168 msg6Count = prevMsgNum = 0;
169
170 numIdleObserversAdded = numIdleObserversRemoved = 0;
171 currTestCaseNum = -1;
172 addedIdleObserver = removedIdleObserver = passed = cleanUp = false;
173 }
174
175 /*
176 * - function printMsgCounts()
177 */
178 function printMsgCounts() {
179 dump("\nmsg0Count: " + msg0Count +
180 "\nmsg1Count: " + msg1Count +
181 "\nmsg2Count: " + msg2Count +
182 "\nmsg3Count: " + msg3Count +
183 "\nmsg5Count: " + msg5Count +
184 "\nmsg6Count: " + msg6Count +
185 "\n"
186 );
187 }
188
189 function performNextTest() {
190 dump("\nfunction performNextTest()\ncurrTestCaseNum: " + currTestCaseNum +
191 "\ncleanUp: " + cleanUp +
192 "\npassed: " + passed +
193 "\nnumIdleObserversRemoved: " + numIdleObserversRemoved +
194 "\nnumIdleObservesAdded: " + numIdleObserversAdded + "\n");
195
196 switch (currTestCaseNum) {
197 case tcZero:
198 ok(passed, "Test case 0 failed clean up!");
199 caseZeroCleanUp();
200 break;
201 case tcAddShiftLocal:
202 if (cleanUp && numIdleObserversRemoved === 1) {
203 passed = true;
204 ok(passed, "Failed test case AddShiftLocalCleanUp()");
205 if (AddNewLocalWhileAllIdleEnabled) {
206 AddNewLocalWhileAllIdle();
207 }
208 else {
209 SimpleTest.finish();
210 }
211 }
212 break;
213 case tcAddNewLocalWhileAllIdle:
214 ok(passed, "Failed test case: AddNewLocalWhileAllIdle()");
215 AddNewLocalWhileAllIdleCleanUp();
216 break;
217 default:
218 //do nothing.
219 break;
220 }
221 }
222
223 //Place Holder.
224 var idleHandler0 = function() { dump("rmsg 0, should never be used!\n"); };
225
226 //idleHandler1
227 function idleHandler1() {
228 msg1Count++;
229 dump("msg 1 Count: " + msg1Count + "\n");
230
231 switch (currTestCaseNum) {
232 case tcAddOutOfOrderIdle:
233 if (msg1Count === 1 && msg2Count === 1 && msg3Count === 1) {
234 idleServiceObj.idleTime = 0;
235 idleServiceObj.testIdleBackService(idleObserversArray[1], "active");
236 }
237 else if (msg1Count === 4 && msg2Count === 4 && msg3Count === 4) {
238 passed = true;
239 AddOutOfOrderIdleCleanUp();
240 }
241 break;
242 case tcTestActiveToActiveNotification:
243 if (msg1Count === 1 && !msg2Count && !msg3Count && !msg4Count && !msg5Count) {
244 idleServiceObj.idleTime = 500;
245 idleServiceObj.testIdleBackService(idleObserversArray[1], "active");
246 return;
247 }
248
249 if (msg1Count === 2 && !msg2Count && !msg3Count && !msg4Count && !msg5Count) {
250 idleServiceObj.idleTime = 1000;
251 idleServiceObj.testIdleBackService(idleObserversArray[1], "idle");
252 return;
253 }
254
255 if (msg1Count === 3 && !msg2Count && !msg3Count && !msg4Count && !msg5Count) {
256 return;
257 }
258 ok(false, "Failed test active to active notification.");
259 SimpleTest.finish();
260 break;
261 default:
262 break;
263 }
264 }
265
266 //idleHandler2
267 function idleHandler2() {
268 msg2Count++;
269 dump("msg 2 Count: " + msg2Count + "\n");
270
271 switch (currTestCaseNum) {
272 case tcZero:
273 switch (msg2Count) {
274 case 2:
275 passed = true;
276 performNextTest();
277 break;
278 default:
279 break;
280 }
281 break;
282 case tcAddOutOfOrderIdle:
283 if (msg3Count === 1 && msg2Count === 1 && !msg1Count) {
284 idleServiceObj.idleTime = 4000;
285 window.navigator.addIdleObserver(idleObserversArray[1]);
286 }
287 break;
288 case tcAddShiftLocal:
289 if (!msg1Count && msg2Count === 1 && !msg3Count && !msg4Count) {
290 window.navigator.addIdleObserver(idleObserversArray[3]);
291 }
292 AddShiftLocalCleanUp();
293 break;
294 case tcAddNewLocalWhileAllIdle:
295 if (msg1Count === 1 && msg2Count === 2) {
296 idleServiceObj.idleTime = 3500;
297 window.navigator.addIdleObserver(idleObserversArray[5]);
298 }
299 break;
300 case (tcShiftLocalTimerBack):
301 if (!msg1Count && msg2Count === 1 && !msg3Count && !msg4Count && !msg5Count) {
302 window.navigator.addIdleObserver(idleObserversArray[5]);
303 window.navigator.addIdleObserver(idleObserversArray[4]);
304 }
305 break;
306 default:
307 //do nothing.
308 break;
309 }
310 }
311
312 //idleHandler3
313 function idleHandler3() {
314 msg3Count++;
315 dump("msg 3 Count: " + msg3Count + "\n");
316
317 switch (currTestCaseNum) {
318 case (tcAddOutOfOrderIdle):
319 if (msg3Count === 1) {
320 idleServiceObj.idleTime = 3500;
321 window.navigator.addIdleObserver(idleObserversArray[2]);
322 }
323 if (msg1Count === 2 && msg2Count === 2 && msg3Count === 2) {
324 idleServiceObj.idleTime = 1000;
325 idleServiceObj.testIdleBackService(idleObserversArray[1], "idle");
326 }
327 else if (msg1Count === 3 && msg2Count === 3 && msg3Count === 3) {
328 AddOutOfOrderIdle();
329 }
330 else if (msg1Count === 3 && msg2Count === 3 && msg3Count === 4) {
331 passed = true;
332 AddOutOfOrderIdleCleanUp();
333 }
334 break;
335 default:
336 break;
337 }
338 }
339
340 //idleHandler4
341 function idleHandler4() {
342 msg4Count++;
343 dump("msg 4 Count: " + msg4Count + "\n");
344
345 switch (currTestCaseNum) {
346 case tcAddOutOfOrderActive:
347 if (msg1Count && msg2Count && msg3Count && msg4Count) {
348 passed = true;
349 ok(passed, "idleHandler4: failed AddOutOfOrderActive()");
350 AddOutOfOrderActiveCleanUp();
351 cleanUp = true;
352 }
353 break;
354 case tcAddShiftLocal:
355 if (msg1Count === 1 && msg3Count === 1 && msg4Count === 1) {
356 idleServiceObj.idleTime = 3200;
357 window.navigator.addIdleObserver(idleObserversArray[2]);
358 }
359 break;
360 default:
361 //do nothing.
362 break;
363 }
364 }
365
366 //idleHandler5
367 function idleHandler5() {
368 msg5Count++;
369 dump("msg 5 Count: " + msg5Count + "\n");
370
371 switch (currTestCaseNum) {
372 case tcAddNewLocalWhileAllIdle:
373 if (msg1Count === 1 && msg2Count === 2 && msg5Count === 1) {
374 passed = true;
375 performNextTest();
376 }
377 break;
378 case tcShiftLocalTimerBack:
379 if (!msg1Count && msg2Count === 1 && !msg3Count && msg4Count === 1 && msg5Count === 1) {
380 passed = true;
381 ShiftLocalTimerBackCleanUp();
382 }
383 break;
384 case tcTestActiveToActiveNotification:
385 passed = false;
386 if (msg1Count === 3 && !msg2Count && !msg3Count && !msg4Count && msg5Count === 1) {
387 passed = true;
388 }
389 ok(passed, "Failed TestActiveToActiveNotification.");
390 TestActiveNotificationCleanUp();
391 break;
392 default:
393 //do nothing.
394 break;
395 }
396 }
397
398 //idleHandler6
399 function idleHandler6() {
400 dump("msg 6 Count: " + msg6Count + "\n");
401 }
402
403 var idleObserversArray = [];
404 idleObserversArray[0] = {time: 0, onidle: idleHandler0, onactive: idleHandler0};
405 idleObserversArray[1] = {time: 1, onidle: idleHandler1, onactive: idleHandler1};
406 idleObserversArray[2] = {time: 2, onidle: idleHandler2, onactive: idleHandler2};
407 idleObserversArray[3] = {time: 3, onidle: idleHandler3, onactive: idleHandler3};
408 idleObserversArray[4] = {time: 4, onidle: idleHandler4, onactive: idleHandler4};
409 idleObserversArray[5] = {time: 5, onidle: idleHandler5, onactive: idleHandler5};
410 idleObserversArray[6] = {time: 0, onidle: idleHandler6, onactive: idleHandler6};
411 idleObserversArray[7] = {time: 2, onidle: null, onactive: null};
412
413 idleServiceObj.observers.push( {observer: idleObserversArray[0], time: 0, } );
414
415 /*
416 * - case 0
417 * - AddSingleIdleObserver
418 * - takes care of adding duplicate local too
419 * - user is currently idle since the
420 * requested idle time of 2s < current idle time of 5000ms set below.
421 */
422 function caseZero() {
423 dump("\n\nTESTING CASE 0\n");
424 dump("==============\n");
425
426 ResetVars();
427 currTestCaseNum = tcZero;
428 idleServiceObj.idleTime = 5000;
429
430 window.navigator.addIdleObserver(idleObserversArray[2]);
431 idleServiceObj.testIdleBackService(idleObserversArray[2], "idle");
432 window.navigator.addIdleObserver(idleObserversArray[2]);
433 }
434
435 function caseZeroCleanUp() {
436 dump("\ncaseZeroCleanUp()\n");
437 dump("==============\n");
438 ResetVars();
439 currTestCaseNum = tcZero;
440 cleanUp = false;
441
442 window.navigator.removeIdleObserver(idleObserversArray[2]);
443 window.navigator.removeIdleObserver(idleObserversArray[2]);
444
445 if (AddOutOfOrderActiveEnabled) {
446 AddOutOfOrderActive();
447 }
448 else {
449 dump("Finishing testing idle API.\n");
450 SimpleTest.finish();
451 }
452 }
453
454 /*
455 AddOutOfOrderActive()
456 - Tests if the idle observer with the min time is always registered correctly
457 with the idle service.
458 */
459 function AddOutOfOrderActive() {
460 dump("\n\nTESTING CASE AddOutOfOrderActive\n");
461 dump("==============\n");
462
463 ResetVars();
464 currTestCaseNum = tcAddOutOfOrderActive;
465 idleServiceObj.idleTime = 500;
466
467 window.navigator.addIdleObserver(idleObserversArray[3]); //msg3
468 window.navigator.addIdleObserver(idleObserversArray[4]); //msg4
469 window.navigator.addIdleObserver(idleObserversArray[1]); //msg1
470 window.navigator.addIdleObserver(idleObserversArray[2]); //msg2
471 passed = false;
472
473 idleServiceObj.idleTime = 1000;
474 idleServiceObj.testIdleBackService(idleObserversArray[1], "idle");
475 }
476
477 /*
478 - AddOutOfOrderActiveCleanUp()
479 */
480 function AddOutOfOrderActiveCleanUp() {
481 dump("\nAddOutOfOrderActiveCleanUp()\n");
482 dump("==============================\n");
483 ResetVars();
484 currTestCaseNum = tcAddOutOfOrderActive;
485 cleanUp = false;
486 idleServiceObj.idleTime = 4500;
487
488 for (var i=1; i<5; i++) {
489 window.navigator.removeIdleObserver(idleObserversArray[i]);
490 }
491 dump("JS AddOutOfOrderActiveCleanUp() DONE\n");
492 if (AddOutOfOrderIdleEnabled) {
493 AddOutOfOrderIdle();
494 }
495 else {
496 dump("Finishing testing idle API.\n");
497 SimpleTest.finish();
498 }
499 }
500
501 /*
502 - AddOutOfOrderIdle()
503 */
504 function AddOutOfOrderIdle() {
505 dump("\nAddOutOfOrderIdle()\n");
506 dump("======================================================================\n");
507
508 dump("\nJS AddOutOfOrderIdle\n");
509 dump("JS NUM OBSERVERS: " + idleServiceObj.observers.length + "\n");
510
511 if (!msg1Count && !msg2Count && !msg3Count) {
512 ResetVars();
513 }
514 currTestCaseNum = tcAddOutOfOrderIdle;
515 cleanUp = false;
516
517 if (!msg1Count && !msg2Count && !msg3Count) {
518 idleServiceObj.idleTime = 3100;
519 }
520 window.navigator.addIdleObserver(idleObserversArray[3]);
521 if (!msg1Count && !msg2Count && !msg3Count) {
522 idleServiceObj.testIdleBackService(idleObserversArray[3], "idle");
523 }
524 }
525
526 /*
527 - AddOutOfOrderIdleCleanUp()
528 */
529 function AddOutOfOrderIdleCleanUp() {
530 ok(passed, "Failed test case: AddOutOfOrderIdle()");
531 dump("\nAddOutOfOrderIdleCleanUp()\n");
532 dump("==========================\n");
533 ResetVars();
534 currTestCaseNum = tcAddOutOfOrderIdle;
535 cleanUp = true;
536 idleServiceObj.idleTime = 4100;
537
538 for (var j=1; j<4; j++) {
539 window.navigator.removeIdleObserver(idleObserversArray[j]);
540 }
541 window.navigator.removeIdleObserver(idleObserversArray[3]);
542
543 if (idleServiceObj.observers.length === 1) {
544 passed = true;
545 }
546 else {
547 passed = false;
548 }
549 ok(passed, "Failed test case: AddOutOfOrderIdleCleanUp()");
550 if (AddShiftLocalEnabled) {
551 AddShiftLocal();
552 }
553 else {
554 dump("Finished AddOutOfOrderIdleCleanUp() test.\n");
555 SimpleTest.finish();
556 }
557 }
558
559 /*
560 * function AddShiftLocal()
561 * - user is idle
562 * - check that local idle timer is shifted correctly
563 * - msg 1 fired when user is idle
564 * - msg 3 fired when 3000
565 * - msg 2 fired immediately when added at 3200 ms
566 * - msg 4 fired by local timer.
567 */
568 function AddShiftLocal()
569 {
570 dump("\n\nTESTING CASE AddShiftLocal\n");
571 dump("==============\n");
572
573 ResetVars();
574 currTestCaseNum = tcAddShiftLocal;
575 idleServiceObj.idleTime = 500;
576
577 window.navigator.addIdleObserver(idleObserversArray[1]);
578 window.navigator.addIdleObserver(idleObserversArray[3]);
579 window.navigator.addIdleObserver(idleObserversArray[4]);
580
581 idleServiceObj.idleTime = 1000;
582 idleServiceObj.testIdleBackService(idleObserversArray[1], "idle");
583 }
584
585 /*
586 * function AddShiftLocalCleanUp()
587 */
588 function AddShiftLocalCleanUp()
589 {
590 dump("\n\nTESTING CASE AddShiftLocalCleanUp\n");
591 dump("==============\n");
592
593 ResetVars();
594 currTestCaseNum = tcAddShiftLocal;
595
596 for (var i=1; i<5; i++) {
597 window.navigator.removeIdleObserver(idleObserversArray[i]);
598 }
599 dump("AddShiftLocalCleanUp() done clean up\n");
600 if (AddNewLocalWhileAllIdleEnabled) {
601 AddNewLocalWhileAllIdle();
602 }
603 else {
604 dump("Finished testing AddShiftLocal()\n");
605 SimpleTest.finish();
606 }
607 }
608
609 /*
610 * AddNewLocalWhileAllIdle()
611 * - no local idle timer exists because all of the idle observers that were added had a requested
612 * idle time of < curr user idle time and so were fired immediately. No local timer was required.
613 * - now add an idle observer whose requested idle time is > current use idle time and > min idle
614 * requested time in the list of idle observers.
615 */
616 function AddNewLocalWhileAllIdle()
617 {
618 dump("\n\nTESTING CASE AddNewLocalWhileAllIdle\n");
619 dump("==============\n");
620
621 ResetVars();
622 currTestCaseNum = tcAddNewLocalWhileAllIdle;
623 idleServiceObj.idleTime = 500;
624
625 window.navigator.addIdleObserver(idleObserversArray[1]);
626 window.navigator.addIdleObserver(idleObserversArray[2]);
627 window.navigator.addIdleObserver(idleObserversArray[2]);
628
629 idleServiceObj.idleTime = 1000;
630 idleServiceObj.testIdleBackService(idleObserversArray[1], "idle");
631 }
632
633 function AddNewLocalWhileAllIdleCleanUp()
634 {
635 dump("\n\nTESTING CASE AddNewLocalWhileAllIdleCleanUp\n");
636 dump("==============\n");
637
638 ResetVars();
639 currTestCaseNum = tcAddNewLocalWhileAllIdle;
640
641 window.navigator.removeIdleObserver(idleObserversArray[1]);
642 window.navigator.removeIdleObserver(idleObserversArray[2]);
643 window.navigator.removeIdleObserver(idleObserversArray[2]);
644 window.navigator.removeIdleObserver(idleObserversArray[5]);
645
646 if (ShiftLocalTimerBackEnabled) {
647 ShiftLocalTimerBack();
648 }
649 else {
650 dump("Finished testing TestActiveToActiveNotificationCleanUp()\n");
651 SimpleTest.finish();
652 }
653 }
654
655 /*
656 * ShiftLocalTimerBack()
657 * - add a new idle observer whose requested time is > current user idle time
658 * but < the current local timer that has been set.
659 * - the local timer will need to be reset to fire the new msg added.
660 * RESULT
661 * - should print all of them in order
662 */
663 function ShiftLocalTimerBack()
664 {
665 dump("\n\nTESTING CASE ShiftLocalTimerBack()\n");
666 dump("==============\n");
667
668 ResetVars();
669 currTestCaseNum = tcShiftLocalTimerBack;
670 idleServiceObj.idleTime = 2100;
671
672 window.navigator.addIdleObserver(idleObserversArray[2]);
673 idleServiceObj.testIdleBackService(idleObserversArray[2], "idle");
674 }
675
676 function ShiftLocalTimerBackCleanUp()
677 {
678 dump("\n\nTESTING CASE ShiftLocalTimerBackCleanUp\n");
679 dump("==============\n");
680
681 ResetVars();
682 currTestCaseNum = tcShiftLocalTimerBack;
683 window.navigator.removeIdleObserver(idleObserversArray[2]);
684 window.navigator.removeIdleObserver(idleObserversArray[4]);
685 window.navigator.removeIdleObserver(idleObserversArray[5]);
686 dump("ShiftLocalTimerBackCleanUp() done clean up\n");
687
688 if (TestActiveToActiveNotificationEnabled) {
689 TestActiveNotification();
690 }
691 else {
692 dump("Finished testing AddNewLocalWhileAllIdle()\n");
693 SimpleTest.finish();
694 }
695 }
696
697 function TestActiveNotification()
698 {
699 dump("\n\nTESTING CASE TestActiveNotification\n");
700 dump("===============================================\n");
701
702 ResetVars();
703 currTestCaseNum = tcTestActiveToActiveNotification;
704
705 idleServiceObj.idleTime = 500;
706 window.navigator.addIdleObserver(idleObserversArray[1]);
707 window.navigator.addIdleObserver(idleObserversArray[5]);
708 idleServiceObj.idleTime = 1000;
709 idleServiceObj.testIdleBackService(idleObserversArray[1], "idle");
710 }
711
712 function TestActiveNotificationCleanUp()
713 {
714 dump("\n\nTESTING CASE TestActiveNotificationCleanUp\n");
715 dump("===============================================\n");
716
717 try {
718 componentMgr.unregisterFactory(idleServiceCID, idleServiceObj);
719 }
720 catch(err) {
721 dump("test_bug715041.xul: ShiftLocalTimerBackCleanUp() Failed to unregister factory, mock idle service!\n");
722 }
723
724 try {
725 componentMgr.registerFactory(oldIdleServiceCID, "Re registering old idle service", idleServiceContractID, oldIdleServiceFactoryObj);
726 }
727 catch(err) {
728 dump("test_bug715041.xul: ShiftLocalTimerBackCleanUp() Failed to register factory, original idle service!\n");
729 }
730
731 SimpleTest.finish();
732 }
733
734 /*
735 * function AddRemoveIdleObserverWithInvalidTime()
736 */
737 function AddRemoveIdleObserverWithInvalidTime()
738 {
739 dump("\n\nTESTING CASE AddRemoveIdleObserverWithInvalidTime()\n");
740 dump("==============\n");
741
742 ResetVars();
743 currTestCaseNum = tcAddRemoveIdleObserverWithInvalidTime;
744
745 //while idle
746 idleServiceObj.idleTime = 2100;
747 var rv = window.navigator.addIdleObserver(idleObserversArray[6]);
748 dump("rv: " + rv + "\n");
749 rv = window.navigator.removeIdleObserver(idleObserversArray[6]);
750
751 idleServiceObj.idleTime = 0;
752 window.navigator.addIdleObserver(idleObserversArray[6]);
753 window.navigator.removeIdleObserver(idleObserversArray[6]);
754
755 SimpleTest.finish();
756 }
757
758 try {
759 var idleServiceCID = Components.ID("287075a6-f968-4516-8043-406c46f503b4");
760 var idleServiceContractID = "@mozilla.org/widget/idleservice;1";
761 var oldIdleService = Components.classes[idleServiceContractID].getService(Components.interfaces.nsIIdleService);
762 }
763 catch(ex) {
764 dump("test_bug715041.xul: 1) Failed to get old idle service.\n");
765 }
766
767 try {
768 // Registering new moch JS idle service
769 var componentMgr = Components.manager.QueryInterface(Components.interfaces.nsIComponentRegistrar);
770 }
771 catch(err) {
772 dump("test_bug715041.xul: Failed to query component registrar interface.\n");
773 }
774
775 try {
776 var oldIdleServiceFactoryObj = componentMgr.getClassObjectByContractID(idleServiceContractID, Components.interfaces.nsIFactory);
777 }
778 catch(err) {
779 dump("test_bug715041.xul: Failed to get old idle service.\n");
780 }
781
782 try {
783 var oldIdleServiceCID = componentMgr.contractIDToCID(idleServiceContractID);
784 }
785 catch(err) {
786 dump("test_bug715041.xul: Failed to convert ID to CID for old idle service.\n");
787 }
788
789 try {
790 componentMgr.unregisterFactory(oldIdleServiceCID, oldIdleServiceFactoryObj);
791 }
792 catch(err) {
793 dump("test_bug715041.xul: Failed to unregister old idle service factory object!\n");
794 }
795
796 try {
797 componentMgr.registerFactory(idleServiceCID, "Test Simple Idle/Back Notifications", idleServiceContractID, idleServiceObj);
798 }
799 catch(err) {
800 dump("test_bug715041.xul: Failed to register mock idle service.\n");
801 }
802
803 SimpleTest.waitForExplicitFinish();
804 SimpleTest.requestLongerTimeout(10);
805
806 AddOutOfOrderActiveEnabled = true;
807 AddOutOfOrderIdleEnabled = true;
808 AddNewLocalWhileAllIdleEnabled = true;
809 TestActiveToActiveNotificationEnabled = true;
810 AddShiftLocalEnabled = true;
811 AddIdleObserverWithInvalidTimeEnabled = false;
812
813 caseZero();
814
815 ]]>
816 </script>
817 </window>
818

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial