|
160
|
1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
|
|
|
2 *
|
|
|
3 * Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
4 * of this software and associated documentation files (the "Software"), to
|
|
|
5 * deal in the Software without restriction, including without limitation the
|
|
|
6 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
|
7 * sell copies of the Software, and to permit persons to whom the Software is
|
|
|
8 * furnished to do so, subject to the following conditions:
|
|
|
9 *
|
|
|
10 * The above copyright notice and this permission notice shall be included in
|
|
|
11 * all copies or substantial portions of the Software.
|
|
|
12 *
|
|
|
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
18 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
19 * IN THE SOFTWARE.
|
|
|
20 */
|
|
|
21
|
|
|
22 /* Tests commented out with XXX are ones that are failing on Linux */
|
|
|
23
|
|
|
24 /*
|
|
|
25 * Purpose of this test is to check semantics of starting and stopping
|
|
|
26 * prepare, check and idle watchers.
|
|
|
27 *
|
|
|
28 * - A watcher must be able to safely stop or close itself;
|
|
|
29 * - Once a watcher is stopped or closed its callback should never be called.
|
|
|
30 * - If a watcher is closed, it is implicitly stopped and its close_cb should
|
|
|
31 * be called exactly once.
|
|
|
32 * - A watcher can safely start and stop other watchers of the same type.
|
|
|
33 * - Prepare and check watchers are called once per event loop iterations.
|
|
|
34 * - All active idle watchers are queued when the event loop has no more work
|
|
|
35 * to do. This is done repeatedly until all idle watchers are inactive.
|
|
|
36 * - If a watcher starts another watcher of the same type its callback is not
|
|
|
37 * immediately queued. For check and prepare watchers, that means that if
|
|
|
38 * a watcher makes another of the same type active, it'll not be called until
|
|
|
39 * the next event loop iteration. For idle. watchers this means that the
|
|
|
40 * newly activated idle watcher might not be queued immediately.
|
|
|
41 * - Prepare, check, idle watchers keep the event loop alive even when they're
|
|
|
42 * not active.
|
|
|
43 *
|
|
|
44 * This is what the test globally does:
|
|
|
45 *
|
|
|
46 * - prepare_1 is always active and counts event loop iterations. It also
|
|
|
47 * creates and starts prepare_2 every other iteration. Finally it verifies
|
|
|
48 * that no idle watchers are active before polling.
|
|
|
49 * - prepare_2 is started by prepare_1 every other iteration. It immediately
|
|
|
50 * stops itself. It verifies that a watcher is not queued immediately
|
|
|
51 * if created by another watcher of the same type.
|
|
|
52 * - There's a check watcher that stops the event loop after a certain number
|
|
|
53 * of iterations. It starts a varying number of idle_1 watchers.
|
|
|
54 * - Idle_1 watchers stop themselves after being called a few times. All idle_1
|
|
|
55 * watchers try to start the idle_2 watcher if it is not already started or
|
|
|
56 * awaiting its close callback.
|
|
|
57 * - The idle_2 watcher always exists but immediately closes itself after
|
|
|
58 * being started by a check_1 watcher. It verifies that a watcher is
|
|
|
59 * implicitly stopped when closed, and that a watcher can close itself
|
|
|
60 * safely.
|
|
|
61 * - There is a repeating timer. It does not keep the event loop alive
|
|
|
62 * (ev_unref) but makes sure that the loop keeps polling the system for
|
|
|
63 * events.
|
|
|
64 */
|
|
|
65
|
|
|
66
|
|
|
67 #include "uv.h"
|
|
|
68 #include "task.h"
|
|
|
69
|
|
|
70 #include <math.h>
|
|
|
71
|
|
|
72
|
|
|
73 #define IDLE_COUNT 7
|
|
|
74 #define ITERATIONS 21
|
|
|
75 #define TIMEOUT 100
|
|
|
76
|
|
|
77
|
|
|
78 static uv_prepare_t prepare_1_handle;
|
|
|
79 static uv_prepare_t prepare_2_handle;
|
|
|
80
|
|
|
81 static uv_check_t check_handle;
|
|
|
82
|
|
|
83 static uv_idle_t idle_1_handles[IDLE_COUNT];
|
|
|
84 static uv_idle_t idle_2_handle;
|
|
|
85
|
|
|
86 static uv_timer_t timer_handle;
|
|
|
87
|
|
|
88
|
|
|
89 static int loop_iteration = 0;
|
|
|
90
|
|
|
91 static int prepare_1_cb_called = 0;
|
|
|
92 static int prepare_1_close_cb_called = 0;
|
|
|
93
|
|
|
94 static int prepare_2_cb_called = 0;
|
|
|
95 static int prepare_2_close_cb_called = 0;
|
|
|
96
|
|
|
97 static int check_cb_called = 0;
|
|
|
98 static int check_close_cb_called = 0;
|
|
|
99
|
|
|
100 static int idle_1_cb_called = 0;
|
|
|
101 static int idle_1_close_cb_called = 0;
|
|
|
102 static int idles_1_active = 0;
|
|
|
103
|
|
|
104 static int idle_2_cb_called = 0;
|
|
|
105 static int idle_2_close_cb_called = 0;
|
|
|
106 static int idle_2_cb_started = 0;
|
|
|
107 static int idle_2_is_active = 0;
|
|
|
108
|
|
|
109
|
|
|
110 static void timer_cb(uv_timer_t* handle) {
|
|
|
111 ASSERT_PTR_EQ(handle, &timer_handle);
|
|
|
112 }
|
|
|
113
|
|
|
114
|
|
|
115 static void idle_2_close_cb(uv_handle_t* handle) {
|
|
|
116 fprintf(stderr, "%s", "IDLE_2_CLOSE_CB\n");
|
|
|
117 fflush(stderr);
|
|
|
118
|
|
|
119 ASSERT_PTR_EQ(handle, (uv_handle_t*)&idle_2_handle);
|
|
|
120
|
|
|
121 ASSERT(idle_2_is_active);
|
|
|
122
|
|
|
123 idle_2_close_cb_called++;
|
|
|
124 idle_2_is_active = 0;
|
|
|
125 }
|
|
|
126
|
|
|
127
|
|
|
128 static void idle_2_cb(uv_idle_t* handle) {
|
|
|
129 fprintf(stderr, "%s", "IDLE_2_CB\n");
|
|
|
130 fflush(stderr);
|
|
|
131
|
|
|
132 ASSERT_PTR_EQ(handle, &idle_2_handle);
|
|
|
133
|
|
|
134 idle_2_cb_called++;
|
|
|
135
|
|
|
136 uv_close((uv_handle_t*)handle, idle_2_close_cb);
|
|
|
137 }
|
|
|
138
|
|
|
139
|
|
|
140 static void idle_1_cb(uv_idle_t* handle) {
|
|
|
141 int r;
|
|
|
142
|
|
|
143 fprintf(stderr, "%s", "IDLE_1_CB\n");
|
|
|
144 fflush(stderr);
|
|
|
145
|
|
|
146 ASSERT_NOT_NULL(handle);
|
|
|
147 ASSERT_GT(idles_1_active, 0);
|
|
|
148
|
|
|
149 /* Init idle_2 and make it active */
|
|
|
150 if (!idle_2_is_active && !uv_is_closing((uv_handle_t*)&idle_2_handle)) {
|
|
|
151 r = uv_idle_init(uv_default_loop(), &idle_2_handle);
|
|
|
152 ASSERT_OK(r);
|
|
|
153 r = uv_idle_start(&idle_2_handle, idle_2_cb);
|
|
|
154 ASSERT_OK(r);
|
|
|
155 idle_2_is_active = 1;
|
|
|
156 idle_2_cb_started++;
|
|
|
157 }
|
|
|
158
|
|
|
159 idle_1_cb_called++;
|
|
|
160
|
|
|
161 if (idle_1_cb_called % 5 == 0) {
|
|
|
162 r = uv_idle_stop((uv_idle_t*)handle);
|
|
|
163 ASSERT_OK(r);
|
|
|
164 idles_1_active--;
|
|
|
165 }
|
|
|
166 }
|
|
|
167
|
|
|
168
|
|
|
169 static void idle_1_close_cb(uv_handle_t* handle) {
|
|
|
170 fprintf(stderr, "%s", "IDLE_1_CLOSE_CB\n");
|
|
|
171 fflush(stderr);
|
|
|
172
|
|
|
173 ASSERT_NOT_NULL(handle);
|
|
|
174
|
|
|
175 idle_1_close_cb_called++;
|
|
|
176 }
|
|
|
177
|
|
|
178
|
|
|
179 static void prepare_1_close_cb(uv_handle_t* handle) {
|
|
|
180 fprintf(stderr, "%s", "PREPARE_1_CLOSE_CB");
|
|
|
181 fflush(stderr);
|
|
|
182 ASSERT_PTR_EQ(handle, (uv_handle_t*)&prepare_1_handle);
|
|
|
183
|
|
|
184 prepare_1_close_cb_called++;
|
|
|
185 }
|
|
|
186
|
|
|
187
|
|
|
188 static void check_close_cb(uv_handle_t* handle) {
|
|
|
189 fprintf(stderr, "%s", "CHECK_CLOSE_CB\n");
|
|
|
190 fflush(stderr);
|
|
|
191 ASSERT_PTR_EQ(handle, (uv_handle_t*)&check_handle);
|
|
|
192
|
|
|
193 check_close_cb_called++;
|
|
|
194 }
|
|
|
195
|
|
|
196
|
|
|
197 static void prepare_2_close_cb(uv_handle_t* handle) {
|
|
|
198 fprintf(stderr, "%s", "PREPARE_2_CLOSE_CB\n");
|
|
|
199 fflush(stderr);
|
|
|
200 ASSERT_PTR_EQ(handle, (uv_handle_t*)&prepare_2_handle);
|
|
|
201
|
|
|
202 prepare_2_close_cb_called++;
|
|
|
203 }
|
|
|
204
|
|
|
205
|
|
|
206 static void check_cb(uv_check_t* handle) {
|
|
|
207 int i, r;
|
|
|
208
|
|
|
209 fprintf(stderr, "%s", "CHECK_CB\n");
|
|
|
210 fflush(stderr);
|
|
|
211 ASSERT_PTR_EQ(handle, &check_handle);
|
|
|
212
|
|
|
213 if (loop_iteration < ITERATIONS) {
|
|
|
214 /* Make some idle watchers active */
|
|
|
215 for (i = 0; i < 1 + (loop_iteration % IDLE_COUNT); i++) {
|
|
|
216 r = uv_idle_start(&idle_1_handles[i], idle_1_cb);
|
|
|
217 ASSERT_OK(r);
|
|
|
218 idles_1_active++;
|
|
|
219 }
|
|
|
220
|
|
|
221 } else {
|
|
|
222 /* End of the test - close all handles */
|
|
|
223 uv_close((uv_handle_t*)&prepare_1_handle, prepare_1_close_cb);
|
|
|
224 uv_close((uv_handle_t*)&check_handle, check_close_cb);
|
|
|
225 uv_close((uv_handle_t*)&prepare_2_handle, prepare_2_close_cb);
|
|
|
226
|
|
|
227 for (i = 0; i < IDLE_COUNT; i++) {
|
|
|
228 uv_close((uv_handle_t*)&idle_1_handles[i], idle_1_close_cb);
|
|
|
229 }
|
|
|
230
|
|
|
231 /* This handle is closed/recreated every time, close it only if it is
|
|
|
232 * active. */
|
|
|
233 if (idle_2_is_active) {
|
|
|
234 uv_close((uv_handle_t*)&idle_2_handle, idle_2_close_cb);
|
|
|
235 }
|
|
|
236 }
|
|
|
237
|
|
|
238 check_cb_called++;
|
|
|
239 }
|
|
|
240
|
|
|
241
|
|
|
242 static void prepare_2_cb(uv_prepare_t* handle) {
|
|
|
243 int r;
|
|
|
244
|
|
|
245 fprintf(stderr, "%s", "PREPARE_2_CB\n");
|
|
|
246 fflush(stderr);
|
|
|
247 ASSERT_PTR_EQ(handle, &prepare_2_handle);
|
|
|
248
|
|
|
249 /* Prepare_2 gets started by prepare_1 when (loop_iteration % 2 == 0), and it
|
|
|
250 * stops itself immediately. A started watcher is not queued until the next
|
|
|
251 * round, so when this callback is made (loop_iteration % 2 == 0) cannot be
|
|
|
252 * true. */
|
|
|
253 ASSERT_NE(0, loop_iteration % 2);
|
|
|
254
|
|
|
255 r = uv_prepare_stop((uv_prepare_t*)handle);
|
|
|
256 ASSERT_OK(r);
|
|
|
257
|
|
|
258 prepare_2_cb_called++;
|
|
|
259 }
|
|
|
260
|
|
|
261
|
|
|
262 static void prepare_1_cb(uv_prepare_t* handle) {
|
|
|
263 int r;
|
|
|
264
|
|
|
265 fprintf(stderr, "%s", "PREPARE_1_CB\n");
|
|
|
266 fflush(stderr);
|
|
|
267 ASSERT_PTR_EQ(handle, &prepare_1_handle);
|
|
|
268
|
|
|
269 if (loop_iteration % 2 == 0) {
|
|
|
270 r = uv_prepare_start(&prepare_2_handle, prepare_2_cb);
|
|
|
271 ASSERT_OK(r);
|
|
|
272 }
|
|
|
273
|
|
|
274 prepare_1_cb_called++;
|
|
|
275 loop_iteration++;
|
|
|
276
|
|
|
277 printf("Loop iteration %d of %d.\n", loop_iteration, ITERATIONS);
|
|
|
278 }
|
|
|
279
|
|
|
280
|
|
|
281 TEST_IMPL(loop_handles) {
|
|
|
282 int i;
|
|
|
283 int r;
|
|
|
284
|
|
|
285 r = uv_prepare_init(uv_default_loop(), &prepare_1_handle);
|
|
|
286 ASSERT_OK(r);
|
|
|
287 r = uv_prepare_start(&prepare_1_handle, prepare_1_cb);
|
|
|
288 ASSERT_OK(r);
|
|
|
289
|
|
|
290 r = uv_check_init(uv_default_loop(), &check_handle);
|
|
|
291 ASSERT_OK(r);
|
|
|
292 r = uv_check_start(&check_handle, check_cb);
|
|
|
293 ASSERT_OK(r);
|
|
|
294
|
|
|
295 /* initialize only, prepare_2 is started by prepare_1_cb */
|
|
|
296 r = uv_prepare_init(uv_default_loop(), &prepare_2_handle);
|
|
|
297 ASSERT_OK(r);
|
|
|
298
|
|
|
299 for (i = 0; i < IDLE_COUNT; i++) {
|
|
|
300 /* initialize only, idle_1 handles are started by check_cb */
|
|
|
301 r = uv_idle_init(uv_default_loop(), &idle_1_handles[i]);
|
|
|
302 ASSERT_OK(r);
|
|
|
303 }
|
|
|
304
|
|
|
305 /* don't init or start idle_2, both is done by idle_1_cb */
|
|
|
306
|
|
|
307 /* The timer callback is there to keep the event loop polling unref it as it
|
|
|
308 * is not supposed to keep the loop alive */
|
|
|
309 r = uv_timer_init(uv_default_loop(), &timer_handle);
|
|
|
310 ASSERT_OK(r);
|
|
|
311 r = uv_timer_start(&timer_handle, timer_cb, TIMEOUT, TIMEOUT);
|
|
|
312 ASSERT_OK(r);
|
|
|
313 uv_unref((uv_handle_t*)&timer_handle);
|
|
|
314
|
|
|
315 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
316 ASSERT_OK(r);
|
|
|
317
|
|
|
318 ASSERT_EQ(loop_iteration, ITERATIONS);
|
|
|
319
|
|
|
320 ASSERT_EQ(prepare_1_cb_called, ITERATIONS);
|
|
|
321 ASSERT_EQ(1, prepare_1_close_cb_called);
|
|
|
322
|
|
|
323 ASSERT_EQ(prepare_2_cb_called, ITERATIONS / 2);
|
|
|
324 ASSERT_EQ(1, prepare_2_close_cb_called);
|
|
|
325
|
|
|
326 ASSERT_EQ(check_cb_called, ITERATIONS);
|
|
|
327 ASSERT_EQ(1, check_close_cb_called);
|
|
|
328
|
|
|
329 /* idle_1_cb should be called a lot */
|
|
|
330 ASSERT_EQ(idle_1_close_cb_called, IDLE_COUNT);
|
|
|
331
|
|
|
332 ASSERT_EQ(idle_2_close_cb_called, idle_2_cb_started);
|
|
|
333 ASSERT_OK(idle_2_is_active);
|
|
|
334
|
|
|
335 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
336 return 0;
|
|
|
337 }
|
