The Tor Browser / file comparison

comparison: dom/base/test/test_bug715041_removal.xul

dom/base/test/test_bug715041_removal.xul

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:e778704a2cf1
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 try {
25 var idleServiceCID = Components.ID("6f95d965-4322-4829-8a3c-5dc8a4587f4d");
26 var idleServiceContractID = "@mozilla.org/widget/idleservice;1";
27 var oldIdleService = Components.classes[idleServiceContractID].getService(Components.interfaces.nsIIdleService);
28 }
29 catch (ex) {
30 dump("test_bug715041_removal.xul: failed to get old idle service 1.");
31 }
32
33 //class mock javascript idle service
34 var idleServiceObj = {
35 observers: [],
36 windowObservers: [],
37 idleTimeInMS: 5000, //in milli seconds
38
39 // takes note of the idle observers added as the minimum idle observer
40 //with the idle service
41 timesAdded: [],
42
43 QueryInterface: function(iid) {
44 if (iid.equals(Components.interfaces.nsISupports) ||
45 iid.equals(Components.interfaces.nsIFactory) ||
46 iid.equals(Components.interfaces.nsIIdleService)) {
47 return this;
48 }
49 throw Components.results.NS_ERROR_NO_INTERFACE;
50 },
51
52 createInstance: function(outer, iid) {
53 return this.QueryInterface(iid);
54 },
55
56 get idleTime() {
57 return this.idleTimeInMS; //in milli seconds
58 },
59
60 set idleTime(timeInMS) {
61 this.idleTimeInMS = timeInMS;
62 },
63
64 getWindowFromObserver: function(observer) {
65 try {
66 var interfaceRequestor = observer.QueryInterface(Components.interfaces.nsIInterfaceRequestor);
67 var window = interfaceRequestor.getInterface(Components.interfaces.nsIDOMWindow);
68 return window;
69 }
70 catch (e) {}
71
72 return null;
73 },
74
75 testIdleBackService: function(observer, topic) {
76 dump("\nJS FAKE IDLE SERVICE\n");
77 dump("JS NUM OBSERVERS: " + this.observers.length + "\n");
78
79 if (this.observers.length > 1) {
80 this.observers[1].observer.observe(observer, topic, '\0');
81 dump("JS CALLED OBSERVE FUNCTION!!!\n\n");
82 }
83 },
84
85 addIdleObserver: function(observer, time) {
86 dump("\nJS FAKE IDLE SERVICE add idle observer before\n");
87 dump("JS NUM OBSERVERS: " + this.observers.length + "\n");
88 var window = this.getWindowFromObserver(observer);
89
90 if (window) {
91 this.observers.push({ observer: observer, time: time, });
92 addedIdleObserver = true;
93 numIdleObserversAdded++;
94 this.timesAdded.push(time);
95 dump ("\nMOCK IDLE SERVICE ADDING idle observer with time: " + time + "\n");
96 dump("MOCK IDLE SERVICE: num idle observers added: " + numIdleObserversAdded + "\n\n");
97 }
98 else {
99 dump("SHOULD NEVER GET HERE!");
100 oldIdleService.addIdleObserver(observer, time);
101 addedIdleObserver = false;
102 }
103
104 dump("\nJS FAKE IDLE SERVICE end of add idle observer\n");
105 dump("JS NUM OBSERVERS: " + this.observers.length + "\n");
106 },
107
108 removeIdleObserver: function(observer, time) {
109 dump("\nJS REMOVE IDLE OBSERVER () time to be removed: " + time + "\n");
110 var window = this.getWindowFromObserver(observer);
111 if (!window) {
112 oldIdleService.removeIdleObserver(observer, time);
113 }
114 else {
115 var observerIndex = -1;
116 for (var i=0; i<this.observers.length; i++) {
117 dump("JS removeIdleObserver() observer time: " + this.observers[i].time + "\n");
118 if (this.observers[i].time === time) {
119 observerIndex = i;
120 break;
121 }
122 }
123
124 if (observerIndex != -1 && this.observers.length > 0) {
125 numIdleObserversRemoved++;
126 this.observers.splice(observerIndex, 1);
127 removedIdleObserver = true;
128 dump("MOCK IDLE SERVICE REMOVING idle observer with time " + time + "\n");
129 dump("MOCK IDLE SERVICE numIdleObserversRemoved: " + numIdleObserversRemoved + " numIdleObserversAdded: " + numIdleObserversAdded + "\n\n");
130 }
131 else {
132 removedIdleObserver = false;
133 }
134 }
135 dump("\nJS FAKE IDLE SERVICE end of remove idle observer\n");
136 dump("JS NUM OBSERVERS: " + this.observers.length + "\n");
137 },
138 };
139
140 /** Test for Bug 715041 **/
141 dump("\n\n\nJS STARTING TESTING FOR BUG 715041 REMOVAL\n");
142
143 //bool variables
144 var addedIdleObserver = removedIdleObserver = passed = cleanUp = false;
145
146 //msgXCount
147 var msg0Count = msg1Count = msg2Count = msg3Count = msg4Count = msg5Count =
148 msg6Count = tcZero = currTestCaseNum = prevMsgNum = 0;
149
150 //test case number
151 var tcRemoveHeadIdleObserverWhileActive = 0;
152 var tcRemoveLocalIdleObserverWhileIdle = 1;
153 var tcRemoveHeadIdleObserver = 2;
154 var tcRemoveLocalIdleTimerWhileIdle = 3;
155 var tcRemoveLocalIdleTimerLastElement = 4;
156 var tcRemoveHeadAfterLastLocalFired = 5;
157 var tcRemoveHeadIdleObserverWhileIdleCase1 = 6;
158 var tcRemoveLastAddLast = 7;
159
160 function ResetMsgCounts() {
161 msg0Count = msg1Count = msg2Count = msg3Count = msg4Count = msg5Count =
162 msg6Count = prevMsgNum = 0;
163 }
164
165 function ResetVars() {
166 msg0Count = msg1Count = msg2Count = msg3Count = msg4Count = msg5Count =
167 msg6Count = prevMsgNum = 0;
168
169 numIdleObserversAdded = numIdleObserversRemoved = 0;
170 currTestCaseNum = -1;
171 addedIdleObserver = removedIdleObserver = passed = cleanUp = false;
172 }
173
174 function printVariableValues()
175 {
176 dump("\nfunction printVariableValues()\ncurrTestCaseNum: " + currTestCaseNum +
177 "\ncleanUp: " + cleanUp +
178 "\npassed: " + passed +
179 "\nnumIdleObserversRemoved: " + numIdleObserversRemoved +
180 "\nnumIdleObservesAdded: " + numIdleObserversAdded +
181 "\nmsg1Count " + msg1Count +
182 "\nmsg2Count " + msg2Count +
183 "\nmsg3Count " + msg3Count +
184 "\nmsg4Count " + msg4Count +
185 "\nmsg5Count " + msg5Count +
186 "\n");
187 }
188
189 //Place Holder.
190 var idleHandler0 = function() { dump("msg 0, should never be used!\n"); };
191
192 //idleHandler1
193 function idleHandler1() {
194 msg1Count++;
195 dump("msg 1 Count: " + msg1Count + "\n");
196
197 switch (currTestCaseNum) {
198 case tcRemoveHeadIdleObserver:
199 if (msg1Count === 1 && !msg2Count && !msg3Count && !msg4Count && !msg5Count) {
200 window.navigator.removeIdleObserver(idleObserversArray[1]);
201 }
202 break;
203 case tcRemoveLocalIdleObserverWhileIdle:
204 if (msg1Count === 1 && !msg2Count && !msg3Count && !msg4Count) {
205 window.navigator.removeIdleObserver(idleObserversArray[2]);
206 }
207 break;
208 case tcRemoveLocalIdleTimerWhileIdle:
209 if (msg1Count === 1 && !msg2Count && !msg3Count && !msg4Count) {
210 idleServiceObj.idleTime = 2000;
211 window.navigator.removeIdleObserver(idleObserversArray[3]);
212 }
213 break;
214 case tcRemoveHeadIdleObserverWhileIdleCase1:
215 if (msg1Count === 1 && !msg2Count && !msg3Count && !msg4Count) {
216 for (var i=1; i<4; i++) {
217 window.navigator.addIdleObserver(idleObserversArray[i]);
218 }
219 window.navigator.addIdleObserver(idleObserversArray[2]);
220 window.navigator.addIdleObserver(idleObserversArray[3]);
221
222 idleServiceObj.idleTime = 1200;
223 window.navigator.removeIdleObserver(idleObserversArray[1]);
224 }
225 break;
226 case tcRemoveLocalIdleTimerLastElement:
227 if (msg1Count === 1 && !msg2Count && !msg3Count && !msg4Count && !msg5Count) {
228 idleServiceObj.idleTime = 1500;
229 window.navigator.removeIdleObserver(idleObserversArray[1]);
230 idleServiceObj.idleTime = 1700;
231 window.navigator.addIdleObserver(idleObserversArray[2]);
232 idleServiceObj.idleTime = 2000;
233 idleServiceObj.testIdleBackService(idleObserversArray[2], "idle");
234 }
235 break;
236 case tcRemoveHeadAfterLastLocalFired:
237 if (msg1Count === 1 && !msg2Count && !msg3Count && !msg4Count && !msg5Count) {
238 dump("idle handler 1: case tcRemoveHeadAfterLastLocalFired:\n");
239 window.navigator.addIdleObserver(idleObserversArray[2]);
240 window.navigator.addIdleObserver(idleObserversArray[3]);
241 window.navigator.addIdleObserver(idleObserversArray[4]);
242 }
243 break;
244 case tcRemoveLastAddLast:
245 window.navigator.addIdleObserver(idleObserversArray[2]);
246 window.navigator.addIdleObserver(idleObserversArray[3]);
247 break;
248 default:
249 break;
250 }
251 }
252
253 //idleHandler2
254 function idleHandler2() {
255 msg2Count++;
256 dump("msg 2 Count: " + msg2Count + "\n");
257
258 switch (currTestCaseNum) {
259 case tcRemoveLocalIdleTimerLastElement:
260 if (msg1Count === 1 && msg2Count === 1 && !msg3Count && !msg4Count) {
261 window.navigator.addIdleObserver(idleObserversArray[3]);
262 window.navigator.addIdleObserver(idleObserversArray[4]);
263 window.navigator.removeIdleObserver(idleObserversArray[3]);
264 }
265 break;
266 default:
267 //do nothing.
268 break;
269 }
270 }
271
272 //idleHandler3
273 function idleHandler3() {
274 msg3Count++;
275 dump("msg 3 Count: " + msg3Count + "\n");
276 passed = false;
277 switch (currTestCaseNum) {
278 case tcRemoveHeadIdleObserverWhileActive:
279 if (!msg1Count && msg2Count === 1 && msg3Count === 1) {
280 passed = true;
281 }
282 dump("idleHandler3: passed: " + passed + "\n");
283 RemoveHeadIdleObserverWhileActiveCleanUp();
284 break;
285 case tcRemoveHeadIdleObserverWhileIdleCase1:
286 if (msg3Count != 2 && msg3Count != 4) {
287 return;
288 }
289
290 if (msg1Count === 2 && msg2Count === 2 && msg3Count === 2 && !msg4Count) {
291 passed = true;
292 ok(passed, "Failed test case remove head idle observer while idle case 1, part 1.\n");
293 idleServiceObj.testIdleBackService(idleObserversArray[1], "active");
294 return;
295 }
296
297 if (msg1Count === 3 && msg2Count === 4 && msg3Count === 4 &&
298 !msg4Count && !msg5Count) {
299 passed = true;
300 }
301 RemoveHeadIdleObserverWhileIdleCase1CleanUp();
302 break;
303 case tcRemoveLastAddLast:
304 if (msg1Count === 1 && msg2Count === 1 && msg3Count === 1
305 && !msg4Count && !msg5Count) {
306 idleServiceObj.idleTime = 3200;
307 window.navigator.removeIdleObserver(idleObserversArray[3]);
308 idleServiceObj.idleTime = 3500;
309 window.navigator.addIdleObserver(idleObserversArray[4]);
310 return;
311 }
312 break;
313 case tcRemoveHeadAfterLastLocalFired:
314 if (msg3Count === 1) {
315 return;
316 }
317
318 if (msg1Count === 2 && msg2Count === 2 && msg3Count === 2 && msg4Count === 1) {
319 passed = true;
320 }
321 RemoveHeadAfterLastLocalFiredCleanUp();
322 break;
323 default:
324 break;
325 }
326 }
327
328 //idleHandler4
329 function idleHandler4() {
330 msg4Count++;
331 dump("msg 4 Count: " + msg4Count + "\n");
332
333 switch (currTestCaseNum) {
334 case tcRemoveLocalIdleObserverWhileIdle:
335 if (msg1Count === 1 && !msg2Count && msg3Count === 1 && msg4Count === 1) {
336 passed = true;
337 RemoveLocalIdleObserverWhileIdleCleanUp();
338 }
339 break;
340 case tcRemoveHeadIdleObserver:
341 printVariableValues();
342 if (msg1Count === 1 && msg2Count === 1 && msg3Count === 1 && msg4Count === 1) {
343 passed = true;
344 RemoveHeadIdleObserverCleanUp();
345 }
346 break;
347 case tcRemoveLocalIdleTimerWhileIdle:
348 if (msg1Count === 1 && !msg2Count && !msg3Count && msg4Count === 1) {
349 passed = true;
350 RemoveLocalIdleTimerWhileIdleCleanUp();
351 }
352 break
353 case tcRemoveLocalIdleTimerLastElement:
354 if (msg1Count === 1 && msg2Count === 1 && !msg3Count && msg4Count === 1) {
355 passed = true;
356 ok(passed, "Failed test case remove local idle timer last element.\n");
357 RemoveLocalIdleTimerLastElementCleanUp();
358 }
359 break;
360 case tcRemoveHeadAfterLastLocalFired:
361 if (msg1Count === 1 && msg2Count === 1 && msg3Count === 1 && msg4Count === 1) {
362 window.navigator.removeIdleObserver(idleObserversArray[4]);
363 passed = true;
364 ok(passed, "Failed remove head after last local fired.\n");
365 idleServiceObj.testIdleBackService(idleObserversArray[1], "active");
366 }
367 break;
368 case tcRemoveLastAddLast:
369 if (msg1Count === 1 && msg2Count === 1 && msg3Count === 1 && msg4Count == 1) {
370 idleServiceObj.idleTime = 4100;
371 passed = true;
372 RemoveLastAddLastCleanUp();
373 }
374 break;
375 default:
376 //do nothing.
377 break;
378 }
379 }
380
381 //idleHandler5
382 function idleHandler5() {
383 msg5Count++;
384 dump("msg 5 Count: " + msg5Count + "\n");
385
386 switch (currTestCaseNum) {
387
388 default:
389 //do nothing.
390 break;
391 }
392 }
393
394 //idleHandler6
395 function idleHandler6() {
396 dump("msg 6 Count: " + msg6Count + "\n");
397 }
398
399 var idleObserversArray = [];
400 idleObserversArray[0] = {time: 0, onidle: idleHandler0, onactive: idleHandler0};
401 idleObserversArray[1] = {time: 1, onidle: idleHandler1, onactive: idleHandler1};
402 idleObserversArray[2] = {time: 2, onidle: idleHandler2, onactive: idleHandler2};
403 idleObserversArray[3] = {time: 3, onidle: idleHandler3, onactive: idleHandler3};
404 idleObserversArray[4] = {time: 4, onidle: idleHandler4, onactive: idleHandler4};
405 idleObserversArray[5] = {time: 5, onidle: idleHandler5, onactive: idleHandler5};
406 idleObserversArray[6] = {time: 0, onidle: idleHandler6, onactive: idleHandler6};
407
408 //observers array space holder at index zero
409 idleServiceObj.observers.push( {observer: idleObserversArray[0], time: 0, } );
410
411 /*
412 * - function RemoveHeadIdleObserverWhileActive1()
413 * - Remove head idle observer before the head idle notification is fired by the
414 * idle service. I.e. remove the head idle observer while the user is active.
415 * - RESULT: prints 2 in 2ms, 3
416 */
417 function RemoveHeadIdleObserverWhileActive() {
418 dump("\n\nTESTING CASE RemoveHeadIdleObserverWhileActive\n");
419 dump("=================================\n");
420
421 ResetVars();
422 currTestCaseNum = tcRemoveHeadIdleObserverWhileActive;
423 idleServiceObj.idleTime = 500;
424
425 window.navigator.addIdleObserver(idleObserversArray[1]);
426 dump("test_bug715041_removal.xul: RemoveHeadIdleObserverWhileActive() idle time " + idleServiceObj.idleTime + "\n");
427 window.navigator.addIdleObserver(idleObserversArray[2]);
428 window.navigator.addIdleObserver(idleObserversArray[3]);
429
430 idleServiceObj.idleTime = 800;
431 window.navigator.removeIdleObserver(idleObserversArray[1]);
432
433 idleServiceObj.idleTime = 1000;
434 idleServiceObj.testIdleBackService(idleObserversArray[2], "idle");
435 }
436
437 function RemoveHeadIdleObserverWhileActiveCleanUp() {
438 dump("\nRemoveHeadIdleObserverWhileActiveCleanUp()\n");
439 dump("=====================================\n");
440
441 dump("Passed: " + passed + "\n");
442 ok(passed, "Failed test case: RemoveHeadIdleObserverWhileActive");
443
444 ResetVars();
445 currTestCaseNum = tcRemoveHeadIdleObserverWhileActive;
446 idleServiceObj.idleTime = 3500;
447
448 for (var i=2; i<4; i++) {
449 window.navigator.removeIdleObserver(idleObserversArray[i]);
450 }
451
452 dump("JS RemoveHeadIdleObserverWhileActiveCleanUp() DONE\n");
453 if (RemoveLocalIdleObserverWhileIdleEnabled) {
454 RemoveLocalIdleObserverWhileIdle();
455 }
456 else {
457 dump("Finishing testing idle API.\n");
458 SimpleTest.finish();
459 }
460 }
461
462 /*
463 * function RemoveLocalIdleObserverWhileIdle()
464 * Remove local observer before the local oberver at index 1 is triggered while
465 * the user is idle.
466 * RESULT: should print 1, 3, 4
467 */
468 function RemoveLocalIdleObserverWhileIdle() {
469 dump("\n\nTESTING CASE RemoveLocalIdleObserverWhileIdle\n");
470 dump("=================================\n");
471
472 ResetVars();
473 currTestCaseNum = tcRemoveLocalIdleObserverWhileIdle;
474 idleServiceObj.idleTime = 500;
475
476 window.navigator.addIdleObserver(idleObserversArray[1]);
477 window.navigator.addIdleObserver(idleObserversArray[2]);
478 window.navigator.addIdleObserver(idleObserversArray[3]);
479 window.navigator.addIdleObserver(idleObserversArray[4]);
480
481 idleServiceObj.idleTime = 1000;
482 idleServiceObj.testIdleBackService(idleObserversArray[1], "idle");
483 }
484
485 function RemoveLocalIdleObserverWhileIdleCleanUp() {
486 dump("\nRemoveLocalIdleObserverWhileIdleCleanUp()\n");
487 dump("=====================================\n");
488
489 ok(passed, "Failed test case: RemoveLocalIdleObserverWhileIdleCleanUp()");
490
491 ResetVars();
492 currTestCaseNum = tcRemoveHeadIdleObserverWhileActive;
493 idleServiceObj.idleTime = 3500;
494
495 window.navigator.removeIdleObserver(idleObserversArray[1]);
496 window.navigator.removeIdleObserver(idleObserversArray[3]);
497 window.navigator.removeIdleObserver(idleObserversArray[4]);
498
499 dump("JS RemoveLocalIdleObserverWhileIdleCleanUp() DONE\n");
500 if (RemoveHeadIdleObserverEnabled) {
501 RemoveHeadIdleObserver();
502 }
503 else {
504 dump("Finishing testing idle API.\n");
505 SimpleTest.finish();
506 }
507 }
508
509
510 /*
511 * function RemoveHeadIdleObserver()
512 * Remove head idle observer while the user has been idle for 2400 ms.
513 * - RESULT: prints 1, 2, remove 2, 3, 4
514 */
515 function RemoveHeadIdleObserver() {
516 dump("\n\nTESTING CASE RemoveHeadIdleObserver\n");
517 dump("=================================\n");
518
519 ResetVars();
520 currTestCaseNum = tcRemoveHeadIdleObserver;
521 idleServiceObj.idleTime = 500;
522
523 window.navigator.addIdleObserver(idleObserversArray[1]);
524 window.navigator.addIdleObserver(idleObserversArray[2]);
525 window.navigator.addIdleObserver(idleObserversArray[3]);
526 window.navigator.addIdleObserver(idleObserversArray[4]);
527
528 idleServiceObj.idleTime = 1000;
529 idleServiceObj.testIdleBackService(idleObserversArray[1], "idle");
530 }
531
532 function RemoveHeadIdleObserverCleanUp() {
533 dump("\nRemoveHeadIdleObserverCleanUp()\n");
534 dump("=====================================\n");
535
536 ok(passed, "Failed test case: RemoveHeadIdleObserverCleanUp()");
537
538 ResetVars();
539 currTestCaseNum = tcRemoveHeadIdleObserver;
540 idleServiceObj.idleTime = 3500;
541
542 for (var i=2; i<5; i++) {
543 window.navigator.removeIdleObserver(idleObserversArray[i]);
544 }
545
546 dump("JS RemoveHeadIdleObserverCleanUp() DONE\n");
547 if (RemoveLocalIdleTimerWhileIdleEnabled) {
548 RemoveLocalIdleTimerWhileIdle();
549 }
550 else {
551 dump("Finishing testing idle API.\n");
552 SimpleTest.finish();
553 }
554 }
555
556 /*
557 * RemoveLocalIdleTimerWhileIdle()
558 * - Removes the idle observer that is also set as the current local idle timer callback
559 * local idle observer being removed is NOT at index 1!
560 * - RESULT: should trigger 1 in 1ms and 4 in 4ms
561 */
562 function RemoveLocalIdleTimerWhileIdle()
563 {
564 dump("\n\nTESTING CASE RemoveLocalIdleTimerWhileIdle\n");
565 dump("=================================\n");
566
567 ResetVars();
568 currTestCaseNum = tcRemoveLocalIdleTimerWhileIdle;
569 idleServiceObj.idleTime = 500;
570
571 window.navigator.addIdleObserver(idleObserversArray[1]);
572 window.navigator.addIdleObserver(idleObserversArray[3]);
573 window.navigator.addIdleObserver(idleObserversArray[4]);
574
575 idleServiceObj.idleTime = 1000;
576 idleServiceObj.testIdleBackService(idleObserversArray[1], "idle");
577 }
578
579 function RemoveLocalIdleTimerWhileIdleCleanUp()
580 {
581 dump("\nRemoveLocalIdleTimerWhileIdleCleanUp()\n");
582 dump("=====================================\n");
583
584 ok(passed, "Failed test case: RemoveLocalIdleTimerWhileIdleCleanUp()");
585
586 ResetVars();
587 currTestCaseNum = tcRemoveLocalIdleTimerWhileIdle;
588
589 window.navigator.removeIdleObserver(idleObserversArray[1]);
590 window.navigator.removeIdleObserver(idleObserversArray[4]);
591
592 dump("JS RemoveLocalIdleTimerWhileIdleCleanUp() DONE\n");
593 if (RemoveLocalIdleTimerLastElementEnabled) {
594 RemoveLocalIdleTimerLastElement();
595 }
596 else {
597 dump("Finishing testing idle API.\n");
598 SimpleTest.finish();
599 }
600 }
601
602 /*
603 * function RemoveLocalIdleTimerLastElement()
604 */
605 function RemoveLocalIdleTimerLastElement()
606 {
607 dump("\n\nTESTING CASE RemoveLocalIdleTimerLastElement\n");
608 dump("=================================\n");
609
610 ResetVars();
611 currTestCaseNum = tcRemoveLocalIdleTimerLastElement;
612 idleServiceObj.idleTime = 1200;
613
614 window.navigator.addIdleObserver(idleObserversArray[1]);
615 idleServiceObj.testIdleBackService(idleObserversArray[1], "idle");
616 }
617
618 function RemoveLocalIdleTimerLastElementCleanUp() {
619 dump("\nRemoveLocalIdleTimerLastElementCleanUp()\n");
620 dump("=====================================\n");
621
622 ok(passed, "Failed test case: RemoveLocalIdleTimerLastElementCleanUp()");
623
624 ResetVars();
625 currTestCaseNum = tcRemoveLocalIdleTimerLastElement;
626 window.navigator.removeIdleObserver(idleObserversArray[2]);
627 window.navigator.removeIdleObserver(idleObserversArray[4]);
628
629 dump("JS RemoveLocalIdleTimerLastElementCleanUp() DONE\n");
630 if (RemoveHeadAfterLastLocalFiredEnabled) {
631 RemoveHeadAfterLastLocalFired();
632 }
633 else {
634 dump("Finishing testing idle API.\n");
635 SimpleTest.finish();
636 }
637 }
638
639 /*
640 - Remove the head after the last local idle timer has been fired
641 - add 1 2 3 4
642 - after 4 has been notified, removed idle observer with time 4
643 - send a back topic
644 - message notification should be 1, 2, 3.
645 */
646 function RemoveHeadAfterLastLocalFired()
647 {
648 dump("\n\nTESTING CASE RemoveHeadAfterLastLocalFired\n");
649 dump("=================================\n");
650
651 ResetVars();
652 currTestCaseNum = tcRemoveHeadAfterLastLocalFired;
653 idleServiceObj.idleTime = 1200;
654
655 window.navigator.addIdleObserver(idleObserversArray[1]);
656 idleServiceObj.testIdleBackService(idleObserversArray[1], "idle");
657 }
658
659 function RemoveHeadAfterLastLocalFiredCleanUp() {
660 dump("\RemoveHeadAfterLastLocalFiredCleanUp()\n");
661 dump("=====================================\n");
662
663 ok(passed, "Failed test case: RemoveHeadAfterLastLocalFiredCleanUp()");
664
665 ResetVars();
666 currTestCaseNum = tcRemoveHeadAfterLastLocalFired;
667
668 window.navigator.removeIdleObserver(idleObserversArray[1]);
669 window.navigator.removeIdleObserver(idleObserversArray[2]);
670 window.navigator.removeIdleObserver(idleObserversArray[3]);
671
672 dump("JS RemoveHeadAfterLastLocalFiredCleanUp() DONE\n");
673 if (RemoveHeadIdleObserverWhileIdleCase1Enabled) {
674 RemoveHeadIdleObserverWhileIdleCase1();
675 }
676 else {
677 dump("Finishing testing idle API.\n");
678 SimpleTest.finish();
679 }
680 }
681
682 function RemoveHeadIdleObserverWhileIdleCase1() {
683 dump("\n\nTESTING CASE RemoveHeadIdleObserverWhileIdleCase1\n");
684 dump("=================================\n");
685
686 ResetVars();
687 currTestCaseNum = tcRemoveHeadIdleObserverWhileIdleCase1;
688 idleServiceObj.idleTime = 1000;
689 window.navigator.addIdleObserver(idleObserversArray[1]);
690 idleServiceObj.testIdleBackService(idleObserversArray[1], "idle");
691 }
692
693 function RemoveHeadIdleObserverWhileIdleCase1CleanUp() {
694 dump("\nRemoveHeadIdleObserverWhileIdleCase1CleanUp()\n");
695 dump("=====================================\n");
696
697 ok(passed, "Failed test case: RemoveHeadIdleObserverWhileIdleCase1CleanUp()");
698
699 ResetVars();
700 currTestCaseNum = tcRemoveHeadIdleObserverWhileIdleCase1;
701
702 for (var i=1; i<4; i++) {
703 window.navigator.removeIdleObserver(idleObserversArray[i]);
704 }
705
706 window.navigator.removeIdleObserver(idleObserversArray[2]);
707 window.navigator.removeIdleObserver(idleObserversArray[3]);
708
709 dump("JS RemoveHeadIdleObserverWhileIdleCase1CleanUp() DONE\n");
710 if (RemoveLastAddLastEnabled) {
711 RemoveLastAddLast();
712 }
713 else {
714 dump("Finishing testing idle API.\n");
715 SimpleTest.finish();
716 }
717 }
718
719 /*
720 * - RemoveLastAddLast()
721 *
722 * - User is currently idle.
723 * - Add callback 1, 2, 3,
724 * - Remove callback 3 after 3200 MS. I.e. after callback 3 has been notified.
725 * - Add callback 4 after 3500 MS
726 * - Output: 1, 2, 3, 4
727 */
728 function RemoveLastAddLast()
729 {
730 dump("\n\nTESTING CASE RemoveLastAddLast()\n");
731 dump("=================================\n");
732
733 ResetVars();
734 currTestCaseNum = tcRemoveLastAddLast;
735 idleServiceObj.idleTime = 1000;
736 window.navigator.addIdleObserver(idleObserversArray[1]);
737 idleServiceObj.testIdleBackService(idleObserversArray[1], "idle");
738 }
739
740 function RemoveLastAddLastCleanUp()
741 {
742 dump("\RemoveLastAddLastCleanUp()\n");
743 dump("=====================================\n");
744
745 ok(passed, "Failed test case: RemoveLastAddLastCleanUp()");
746
747 ResetVars();
748 currTestCaseNum = tcRemoveLastAddLast;
749
750 window.navigator.removeIdleObserver(idleObserversArray[1]);
751 window.navigator.removeIdleObserver(idleObserversArray[2]);
752 window.navigator.removeIdleObserver(idleObserversArray[4]);
753
754 if (numIdleObserversRemoved === 1 && !numIdleObserversAdded) {
755 ok(true, "Failed test case: RemoveLastAddLastCleanUp()");
756 }
757 else {
758 ok(false, "Failed test case: RemoveLastAddLastCleanUp()");
759 }
760
761
762 try {
763 componentMgr.unregisterFactory(idleServiceCID, idleServiceObj);
764 }
765 catch(err) {
766 dump("test_bug715041_removal.xul: RemoveLastAddLastCleanUp() Failed to unregister factory, mock idle service!\n");
767 }
768
769 try {
770 componentMgr.registerFactory(oldIdleServiceCID, "Re registering old idle service", idleServiceContractID, oldIdleServiceFactoryObj);
771 }
772 catch(err) {
773 dump("test_bug715041_removal.xul: RemoveLastAddLastCleanUp() Failed to register factory, original idle service!\n");
774 }
775
776 dump("JS RemoveLastAddLastCleanUp() DONE\n");
777 dump("Finishing testing idle API.\n");
778 SimpleTest.finish();
779 }
780
781
782 // Registering new moch JS idle service
783 SimpleTest.waitForExplicitFinish();
784 SimpleTest.requestLongerTimeout(10);
785
786 try {
787 var idleServiceCID = Components.ID("0fdc1bbf-3868-4660-9855-0c2e376922bc");
788 var idleServiceContractID = "@mozilla.org/widget/idleservice;1";
789 var oldIdleService = Components.classes[idleServiceContractID].getService(Components.interfaces.nsIIdleService);
790 }
791 catch(ex) {
792 dump("test_bug715041_removal.xul: 1) Failed to get old idle service.\n");
793 }
794
795 try {
796 // Registering new moch JS idle service
797 var componentMgr = Components.manager.QueryInterface(Components.interfaces.nsIComponentRegistrar);
798 }
799 catch(err) {
800 dump("test_bug715041_removal.xul: Failed to query component registrar interface.\n");
801 }
802
803 try {
804 var oldIdleServiceFactoryObj = componentMgr.getClassObjectByContractID(idleServiceContractID, Components.interfaces.nsIFactory);
805 }
806 catch(err) {
807 dump("test_bug715041_removal.xul: Failed to get old idle service.\n");
808 }
809
810 try {
811 var oldIdleServiceCID = componentMgr.contractIDToCID(idleServiceContractID);
812 }
813 catch(err) {
814 dump("test_bug715041._removalxul: Failed to convert ID to CID for old idle service.\n");
815 }
816
817 try {
818 componentMgr.unregisterFactory(oldIdleServiceCID, oldIdleServiceFactoryObj);
819 }
820 catch(err) {
821 dump("test_bug715041_removal.xul: Failed to unregister old idle service factory object!\n");
822 }
823
824 try {
825 componentMgr.registerFactory(idleServiceCID, "Test Simple Idle/Back Notifications", idleServiceContractID, idleServiceObj);
826 }
827 catch(err) {
828 dump("test_bug715041_removal.xul: Failed to register mock idle service.\n");
829 }
830
831 //test case enabled
832 var RemoveLocalIdleObserverWhileIdleEnabled = true;
833 var RemoveHeadIdleObserverEnabled = true;
834 var RemoveLocalIdleTimerWhileIdleEnabled = true;
835 var RemoveLocalIdleTimerLastElementEnabled = true;
836 var RemoveHeadAfterLastLocalFiredEnabled = true;
837 var RemoveHeadIdleObserverWhileIdleCase1Enabled = true;
838 var RemoveLastAddLastEnabled = true;
839
840 RemoveHeadIdleObserverWhileActive();
841
842 ]]>
843 </script>
844 </window>
845

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial