1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
/* Any copyright is dedicated to the Public Domain.
* http://creativecommons.org/publicdomain/zero/1.0/ */
"use strict";
// Tests exports from Timer.sys.mjs
var imported = ChromeUtils.importESModule(
"resource://gre/modules/Timer.sys.mjs"
);
add_task(async function test_setTimeout() {
let timeout1 = imported.setTimeout(
() => do_throw("Should not be called"),
100
);
Assert.equal(typeof timeout1, "number", "setTimeout returns a number");
Assert.greater(timeout1, 0, "setTimeout returns a positive number");
imported.clearTimeout(timeout1);
await new Promise(resolve => {
let timeout2 = imported.setTimeout(
(param1, param2) => {
Assert.ok(true, "Should be called");
Assert.equal(param1, 5, "first parameter is correct");
Assert.equal(param2, "test", "second parameter is correct");
resolve();
},
100,
5,
"test"
);
Assert.equal(typeof timeout2, "number", "setTimeout returns a number");
Assert.greater(timeout2, 0, "setTimeout returns a positive number");
Assert.notEqual(
timeout1,
timeout2,
"Calling setTimeout again returns a different value"
);
});
});
add_task(async function test_setInterval() {
let interval1 = imported.setInterval(
() => do_throw("Should not be called!"),
100
);
Assert.equal(typeof interval1, "number", "setInterval returns a number");
Assert.greater(interval1, 0, "setTimeout returns a positive number");
imported.clearInterval(interval1);
const EXPECTED_CALLS = 5;
let calls = 0;
await new Promise(resolve => {
let interval2 = imported.setInterval(
(param1, param2) => {
Assert.ok(true, "Should be called");
Assert.equal(param1, 15, "first parameter is correct");
Assert.equal(param2, "hola", "second parameter is correct");
if (calls >= EXPECTED_CALLS) {
imported.clearInterval(interval2);
resolve();
}
calls++;
},
100,
15,
"hola"
);
});
});
add_task(async function test_setTimeoutNonFunction() {
Assert.throws(() => {
imported.setTimeout({}, 0);
}, /callback is not a function in setTimeout/);
});
add_task(async function test_setIntervalNonFunction() {
Assert.throws(() => {
imported.setInterval({}, 0);
}, /callback is not a function in setInterval/);
});
add_task(async function test_setTimeoutWithTargetNonFunction() {
Assert.throws(() => {
imported.setTimeoutWithTarget({}, 0);
}, /callback is not a function in setTimeout/);
});
add_task(async function test_setIntervalWithTargetNonFunction() {
Assert.throws(() => {
imported.setIntervalWithTarget({}, 0);
}, /callback is not a function in setInterval/);
});
add_task(async function test_requestIdleCallback() {
let request1 = imported.requestIdleCallback(() =>
do_throw("Should not be called")
);
Assert.equal(
typeof request1,
"number",
"requestIdleCallback returns a number"
);
Assert.greater(request1, 0, "setTimeout returns a positive number");
imported.cancelIdleCallback(request1);
await new Promise(resolve => {
let request2 = imported.requestIdleCallback(
deadline => {
Assert.ok(true, "Should be called");
Assert.equal(
typeof deadline.didTimeout,
"boolean",
"deadline parameter has .didTimeout property"
);
Assert.equal(
typeof deadline.timeRemaining(),
"number",
"deadline parameter has .timeRemaining() function"
);
resolve();
},
{ timeout: 100 }
);
Assert.equal(
typeof request2,
"number",
"requestIdleCallback returns a number"
);
Assert.greater(
request2,
0,
"requestIdleCallback returns a positive number"
);
Assert.notEqual(
request1,
request2,
"Calling requestIdleCallback again returns a different value"
);
});
});
|
