libuv-svace-build

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
#include "uv.h"
23
#include "task.h"
24

25

26
static int once_cb_called = 0;
27
static int once_close_cb_called = 0;
28
static int twice_cb_called = 0;
29
static int twice_close_cb_called = 0;
30
static int repeat_cb_called = 0;
31
static int repeat_close_cb_called = 0;
32
static int order_cb_called = 0;
33
static int timer_check_double_call_called = 0;
34
static int zero_timeout_cb_calls = 0;
35
static uint64_t start_time;
36
static uv_timer_t tiny_timer;
37
static uv_timer_t huge_timer1;
38
static uv_timer_t huge_timer2;
39

40

41
static void once_close_cb(uv_handle_t* handle) {
42
  printf("ONCE_CLOSE_CB\n");
43

44
  ASSERT_NOT_NULL(handle);
45
  ASSERT_OK(uv_is_active(handle));
46

47
  once_close_cb_called++;
48
}
49

50

51
static void once_cb(uv_timer_t* handle) {
52
  printf("ONCE_CB %d\n", once_cb_called);
53

54
  ASSERT_NOT_NULL(handle);
55
  ASSERT_OK(uv_is_active((uv_handle_t*) handle));
56

57
  once_cb_called++;
58

59
  uv_close((uv_handle_t*)handle, once_close_cb);
60

61
  /* Just call this randomly for the code coverage. */
62
  uv_update_time(uv_default_loop());
63
}
64

65
static void twice_close_cb(uv_handle_t* handle) {
66
  printf("TWICE_CLOSE_CB\n");
67

68
  ASSERT_NOT_NULL(handle);
69
  ASSERT_OK(uv_is_active(handle));
70

71
  twice_close_cb_called++;
72
}
73

74
static void twice_cb(uv_timer_t* handle) {
75
  printf("TWICE_CB %d\n", twice_cb_called);
76

77
  ASSERT_NOT_NULL(handle);
78
  ASSERT_OK(uv_is_active((uv_handle_t*) handle));
79

80
  twice_cb_called++;
81

82
  uv_close((uv_handle_t*)handle, twice_close_cb);
83
}
84

85

86

87
static void repeat_close_cb(uv_handle_t* handle) {
88
  printf("REPEAT_CLOSE_CB\n");
89

90
  ASSERT_NOT_NULL(handle);
91

92
  repeat_close_cb_called++;
93
}
94

95

96
static void repeat_cb(uv_timer_t* handle) {
97
  printf("REPEAT_CB\n");
98

99
  ASSERT_NOT_NULL(handle);
100
  ASSERT_EQ(1, uv_is_active((uv_handle_t*) handle));
101

102
  repeat_cb_called++;
103

104
  if (repeat_cb_called == 5) {
105
    uv_close((uv_handle_t*)handle, repeat_close_cb);
106
  }
107
}
108

109

110
static void never_cb(uv_timer_t* handle) {
111
  FATAL("never_cb should never be called");
112
}
113

114

115
TEST_IMPL(timer) {
116
  uv_timer_t once_timers[10];
117
  uv_timer_t *once;
118
  uv_timer_t repeat, never;
119
  unsigned int i;
120
  int r;
121

122
  start_time = uv_now(uv_default_loop());
123
  ASSERT_LT(0, start_time);
124

125
  /* Let 10 timers time out in 500 ms total. */
126
  for (i = 0; i < ARRAY_SIZE(once_timers); i++) {
127
    once = once_timers + i;
128
    r = uv_timer_init(uv_default_loop(), once);
129
    ASSERT_OK(r);
130
    r = uv_timer_start(once, once_cb, i * 50, 0);
131
    ASSERT_OK(r);
132
  }
133

134
  /* The 11th timer is a repeating timer that runs 4 times */
135
  r = uv_timer_init(uv_default_loop(), &repeat);
136
  ASSERT_OK(r);
137
  r = uv_timer_start(&repeat, repeat_cb, 100, 100);
138
  ASSERT_OK(r);
139

140
  /* The 12th timer should not do anything. */
141
  r = uv_timer_init(uv_default_loop(), &never);
142
  ASSERT_OK(r);
143
  r = uv_timer_start(&never, never_cb, 100, 100);
144
  ASSERT_OK(r);
145
  r = uv_timer_stop(&never);
146
  ASSERT_OK(r);
147
  uv_unref((uv_handle_t*)&never);
148

149
  uv_run(uv_default_loop(), UV_RUN_DEFAULT);
150

151
  ASSERT_EQ(10, once_cb_called);
152
  ASSERT_EQ(10, once_close_cb_called);
153
  printf("repeat_cb_called %d\n", repeat_cb_called);
154
  ASSERT_EQ(5, repeat_cb_called);
155
  ASSERT_EQ(1, repeat_close_cb_called);
156

157
  ASSERT_LE(500, uv_now(uv_default_loop()) - start_time);
158

159
  MAKE_VALGRIND_HAPPY(uv_default_loop());
160
  return 0;
161
}
162

163

164
TEST_IMPL(timer_start_twice) {
165
  uv_timer_t once;
166
  int r;
167

168
  r = uv_timer_init(uv_default_loop(), &once);
169
  ASSERT_OK(r);
170
  r = uv_timer_start(&once, never_cb, 86400 * 1000, 0);
171
  ASSERT_OK(r);
172
  r = uv_timer_start(&once, twice_cb, 10, 0);
173
  ASSERT_OK(r);
174
  r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
175
  ASSERT_OK(r);
176

177
  ASSERT_EQ(1, twice_cb_called);
178

179
  MAKE_VALGRIND_HAPPY(uv_default_loop());
180
  return 0;
181
}
182

183

184
TEST_IMPL(timer_init) {
185
  uv_timer_t handle;
186

187
  ASSERT_OK(uv_timer_init(uv_default_loop(), &handle));
188
  ASSERT_OK(uv_timer_get_repeat(&handle));
189
  ASSERT_UINT64_LE(0, uv_timer_get_due_in(&handle));
190
  ASSERT_OK(uv_is_active((uv_handle_t*) &handle));
191

192
  MAKE_VALGRIND_HAPPY(uv_default_loop());
193
  return 0;
194
}
195

196

197
static void order_cb_a(uv_timer_t *handle) {
198
  ASSERT_EQ(order_cb_called++, *(int*)handle->data);
199
}
200

201

202
static void order_cb_b(uv_timer_t *handle) {
203
  ASSERT_EQ(order_cb_called++, *(int*)handle->data);
204
}
205

206

207
TEST_IMPL(timer_order) {
208
  int first;
209
  int second;
210
  uv_timer_t handle_a;
211
  uv_timer_t handle_b;
212

213
  first = 0;
214
  second = 1;
215
  ASSERT_OK(uv_timer_init(uv_default_loop(), &handle_a));
216
  ASSERT_OK(uv_timer_init(uv_default_loop(), &handle_b));
217

218
  /* Test for starting handle_a then handle_b */
219
  handle_a.data = &first;
220
  ASSERT_OK(uv_timer_start(&handle_a, order_cb_a, 0, 0));
221
  handle_b.data = &second;
222
  ASSERT_OK(uv_timer_start(&handle_b, order_cb_b, 0, 0));
223
  ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
224

225
  ASSERT_EQ(2, order_cb_called);
226

227
  ASSERT_OK(uv_timer_stop(&handle_a));
228
  ASSERT_OK(uv_timer_stop(&handle_b));
229

230
  /* Test for starting handle_b then handle_a */
231
  order_cb_called = 0;
232
  handle_b.data = &first;
233
  ASSERT_OK(uv_timer_start(&handle_b, order_cb_b, 0, 0));
234

235
  handle_a.data = &second;
236
  ASSERT_OK(uv_timer_start(&handle_a, order_cb_a, 0, 0));
237
  ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
238

239
  ASSERT_EQ(2, order_cb_called);
240

241
  MAKE_VALGRIND_HAPPY(uv_default_loop());
242
  return 0;
243
}
244

245

246
static void zero_timeout_cb(uv_timer_t* handle) {
247
  ASSERT_OK(uv_timer_start(handle, zero_timeout_cb, 0, 0));
248
  uv_stop(handle->loop);
249
  zero_timeout_cb_calls++;
250
}
251

252

253
TEST_IMPL(timer_zero_timeout) {
254
  uv_timer_t timer;
255
  uv_loop_t* loop;
256

257
  loop = uv_default_loop();
258
  ASSERT_OK(uv_timer_init(loop, &timer));
259
  ASSERT_OK(uv_timer_start(&timer, zero_timeout_cb, 0, 0));
260
  ASSERT_EQ(1, uv_run(loop, UV_RUN_DEFAULT));  /* because of uv_stop() */
261
  ASSERT_EQ(1, zero_timeout_cb_calls);
262
  uv_close((uv_handle_t*) &timer, NULL);
263
  ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
264
  ASSERT_EQ(1, zero_timeout_cb_calls);
265

266
  MAKE_VALGRIND_HAPPY(loop);
267
  return 0;
268
}
269

270

271
static void tiny_timer_cb(uv_timer_t* handle) {
272
  ASSERT_PTR_EQ(handle, &tiny_timer);
273
  uv_close((uv_handle_t*) &tiny_timer, NULL);
274
  uv_close((uv_handle_t*) &huge_timer1, NULL);
275
  uv_close((uv_handle_t*) &huge_timer2, NULL);
276
}
277

278

279
TEST_IMPL(timer_huge_timeout) {
280
  ASSERT_OK(uv_timer_init(uv_default_loop(), &tiny_timer));
281
  ASSERT_OK(uv_timer_init(uv_default_loop(), &huge_timer1));
282
  ASSERT_OK(uv_timer_init(uv_default_loop(), &huge_timer2));
283
  ASSERT_OK(uv_timer_start(&tiny_timer, tiny_timer_cb, 1, 0));
284
  ASSERT_OK(uv_timer_start(&huge_timer1,
285
                           tiny_timer_cb,
286
                           0xffffffffffffLL,
287
                           0));
288
  ASSERT_OK(uv_timer_start(&huge_timer2, tiny_timer_cb, (uint64_t) -1, 0));
289
  ASSERT_UINT64_EQ(1, uv_timer_get_due_in(&tiny_timer));
290
  ASSERT_UINT64_EQ(281474976710655, uv_timer_get_due_in(&huge_timer1));
291
  ASSERT_UINT64_LE(0, uv_timer_get_due_in(&huge_timer2));
292
  ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
293
  MAKE_VALGRIND_HAPPY(uv_default_loop());
294
  return 0;
295
}
296

297

298
static void huge_repeat_cb(uv_timer_t* handle) {
299
  static int ncalls;
300

301
  if (ncalls == 0)
302
    ASSERT_PTR_EQ(handle, &huge_timer1);
303
  else
304
    ASSERT_PTR_EQ(handle, &tiny_timer);
305

306
  if (++ncalls == 10) {
307
    uv_close((uv_handle_t*) &tiny_timer, NULL);
308
    uv_close((uv_handle_t*) &huge_timer1, NULL);
309
  }
310
}
311

312

313
TEST_IMPL(timer_huge_repeat) {
314
  ASSERT_OK(uv_timer_init(uv_default_loop(), &tiny_timer));
315
  ASSERT_OK(uv_timer_init(uv_default_loop(), &huge_timer1));
316
  ASSERT_OK(uv_timer_start(&tiny_timer, huge_repeat_cb, 2, 2));
317
  ASSERT_OK(uv_timer_start(&huge_timer1, huge_repeat_cb, 1, (uint64_t) -1));
318
  ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
319
  MAKE_VALGRIND_HAPPY(uv_default_loop());
320
  return 0;
321
}
322

323

324
static unsigned int timer_run_once_timer_cb_called;
325

326

327
static void timer_run_once_timer_cb(uv_timer_t* handle) {
328
  timer_run_once_timer_cb_called++;
329
}
330

331

332
TEST_IMPL(timer_run_once) {
333
  uv_timer_t timer_handle;
334

335
  ASSERT_OK(uv_timer_init(uv_default_loop(), &timer_handle));
336
  ASSERT_OK(uv_timer_start(&timer_handle, timer_run_once_timer_cb, 0, 0));
337
  ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE));
338
  ASSERT_EQ(1, timer_run_once_timer_cb_called);
339

340
  ASSERT_OK(uv_timer_start(&timer_handle, timer_run_once_timer_cb, 1, 0));
341
  ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE));
342
  ASSERT_EQ(2, timer_run_once_timer_cb_called);
343

344
  uv_close((uv_handle_t*) &timer_handle, NULL);
345
  ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE));
346

347
  MAKE_VALGRIND_HAPPY(uv_default_loop());
348
  return 0;
349
}
350

351

352
TEST_IMPL(timer_is_closing) {
353
  uv_timer_t handle;
354

355
  ASSERT_OK(uv_timer_init(uv_default_loop(), &handle));
356
  uv_close((uv_handle_t *)&handle, NULL);
357

358
  ASSERT_EQ(UV_EINVAL, uv_timer_start(&handle, never_cb, 100, 100));
359

360
  MAKE_VALGRIND_HAPPY(uv_default_loop());
361
  return 0;
362
}
363

364

365
TEST_IMPL(timer_null_callback) {
366
  uv_timer_t handle;
367

368
  ASSERT_OK(uv_timer_init(uv_default_loop(), &handle));
369
  ASSERT_EQ(UV_EINVAL, uv_timer_start(&handle, NULL, 100, 100));
370

371
  MAKE_VALGRIND_HAPPY(uv_default_loop());
372
  return 0;
373
}
374

375

376
static uint64_t timer_early_check_expected_time;
377

378

379
static void timer_early_check_cb(uv_timer_t* handle) {
380
  uint64_t hrtime = uv_hrtime() / 1000000;
381
  ASSERT_GE(hrtime, timer_early_check_expected_time);
382
}
383

384

385
TEST_IMPL(timer_early_check) {
386
  uv_timer_t timer_handle;
387
  const uint64_t timeout_ms = 10;
388

389
  timer_early_check_expected_time = uv_now(uv_default_loop()) + timeout_ms;
390

391
  ASSERT_OK(uv_timer_init(uv_default_loop(), &timer_handle));
392
  ASSERT_OK(uv_timer_start(&timer_handle,
393
                           timer_early_check_cb,
394
                           timeout_ms,
395
                           0));
396
  ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
397

398
  uv_close((uv_handle_t*) &timer_handle, NULL);
399
  ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
400

401
  MAKE_VALGRIND_HAPPY(uv_default_loop());
402
  return 0;
403
}
404

405
static void timer_check_double_call(uv_timer_t* handle) {
406
  timer_check_double_call_called++;
407
}
408

409
TEST_IMPL(timer_no_double_call_once) {
410
  uv_timer_t timer_handle;
411
  const uint64_t timeout_ms = 10;
412

413
  ASSERT_OK(uv_timer_init(uv_default_loop(), &timer_handle));
414
  ASSERT_OK(uv_timer_start(&timer_handle,
415
                           timer_check_double_call,
416
                           timeout_ms,
417
                           timeout_ms));
418
  uv_sleep(timeout_ms * 2);
419
  ASSERT_EQ(1, uv_run(uv_default_loop(), UV_RUN_ONCE));
420
  ASSERT_EQ(1, timer_check_double_call_called);
421

422
  MAKE_VALGRIND_HAPPY(uv_default_loop());
423
  return 0;
424
}
425

426
TEST_IMPL(timer_no_double_call_nowait) {
427
  uv_timer_t timer_handle;
428
  const uint64_t timeout_ms = 10;
429

430
  ASSERT_OK(uv_timer_init(uv_default_loop(), &timer_handle));
431
  ASSERT_OK(uv_timer_start(&timer_handle,
432
                           timer_check_double_call,
433
                           timeout_ms,
434
                           timeout_ms));
435
  uv_sleep(timeout_ms * 2);
436
  ASSERT_EQ(1, uv_run(uv_default_loop(), UV_RUN_NOWAIT));
437
  ASSERT_EQ(1, timer_check_double_call_called);
438

439
  MAKE_VALGRIND_HAPPY(uv_default_loop());
440
  return 0;
441
}
442

443
TEST_IMPL(timer_no_run_on_unref) {
444
  uv_timer_t timer_handle;
445

446
  ASSERT_OK(uv_timer_init(uv_default_loop(), &timer_handle));
447
  ASSERT_OK(uv_timer_start(&timer_handle, (uv_timer_cb) abort, 0, 0));
448
  uv_unref((uv_handle_t*) &timer_handle);
449
  ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
450

451
  MAKE_VALGRIND_HAPPY(uv_default_loop());
452
  return 0;
453
}
454