| @@ -1,4 +1,5 @@ | ||
| { "name":"npm-test-blerg" | ||
| , "version" : "0.0.0" | ||
| , "scripts" : { "test" : "node test.js" } | ||
| , "publishConfig": {"tag": "foo"} | ||
| } |
| @@ -1,4 +1,7 @@ | ||
| { "name":"npm-test-url-dep" | ||
| , "version" : "1.2.3" | ||
| , "dependencies" : | ||
| { "dnode" : "https://github.com/substack/jsonify/tarball/master" | ||
| , "sax": "isaacs/sax-js" | ||
| , "canonical-host": "git://github.com/isaacs/canonical-host" | ||
| } } |
| @@ -114,7 +114,6 @@ | ||
| * [including the GNU Public Licence.] | ||
| */ | ||
|
|
||
|
|
||
| #include <openssl/e_os2.h> | ||
|
|
||
| @@ -711,5 +710,3 @@ static int noecho_fgets(char *buf, int size, FILE *tty) | ||
| return(strlen(buf)); | ||
| } | ||
| #endif | ||
| @@ -15,7 +15,7 @@ | ||
| 'configurations': { | ||
| 'Debug': { | ||
| 'defines': [ 'DEBUG', '_DEBUG' ], | ||
| 'cflags': [ '-g', '-O0', '-fwrapv' ], | ||
| 'msvs_settings': { | ||
| 'VCCLCompilerTool': { | ||
| 'target_conditions': [ | ||
| @@ -73,6 +73,8 @@ static int test_async_pummel(int nthreads) { | ||
| fmt(callbacks / (time / 1e9))); | ||
|
|
||
| free(tids); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
|
|
||
| @@ -113,6 +113,7 @@ static int test_async(int nthreads) { | ||
|
|
||
| free(threads); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
|
|
||
| @@ -131,5 +131,6 @@ BENCHMARK_IMPL(fs_stat) { | ||
| warmup(path); | ||
| sync_bench(path); | ||
| async_bench(path); | ||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -90,5 +90,6 @@ BENCHMARK_IMPL(getaddrinfo) { | ||
| LOGF("getaddrinfo: %.0f req/s\n", | ||
| (double) calls_completed / (double) (end_time - start_time) * 1000.0); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -61,5 +61,6 @@ BENCHMARK_IMPL(million_timers) { | ||
|
|
||
| LOGF("%.2f seconds\n", (after - before) / 1e9); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -416,6 +416,7 @@ static int test_tcp(unsigned int num_servers, unsigned int num_clients) { | ||
| free(clients); | ||
| free(servers); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
|
|
||
| @@ -209,5 +209,6 @@ BENCHMARK_IMPL(ping_pongs) { | ||
|
|
||
| ASSERT(completed_pingers == 1); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -300,6 +300,7 @@ static int pound_it(int concurrency, | ||
| closed_streams / secs, | ||
| conns_failed); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
|
|
||
| @@ -158,5 +158,6 @@ BENCHMARK_IMPL(spawn) { | ||
| LOGF("spawn: %.0f spawns/s\n", | ||
| (double) N / (double) (end_time - start_time) * 1000.0); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -134,7 +134,8 @@ BENCHMARK_IMPL(tcp_write_batch) { | ||
|
|
||
| printf("%ld write requests in %.2fs.\n", | ||
| (long)NUM_WRITE_REQS, | ||
| (stop - start) / 1e9); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -300,7 +300,6 @@ int run_test_part(const char* test, const char* part) { | ||
| if (strcmp(test, task->task_name) == 0 && | ||
| strcmp(part, task->process_name) == 0) { | ||
| r = task->main(); | ||
| return r; | ||
| } | ||
| } | ||
| @@ -78,5 +78,6 @@ TEST_IMPL(active) { | ||
|
|
||
| ASSERT(close_cb_called == 1); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -116,5 +116,6 @@ TEST_IMPL(async) { | ||
|
|
||
| ASSERT(0 == uv_thread_join(&thread)); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -72,5 +72,6 @@ TEST_IMPL(callback_order) { | ||
| ASSERT(idle_cb_called == 1); | ||
| ASSERT(timer_cb_called == 1); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -184,5 +184,6 @@ TEST_IMPL(delayed_accept) { | ||
| ASSERT(connect_cb_called == 2); | ||
| ASSERT(close_cb_called == 7); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -141,5 +141,6 @@ TEST_IMPL(fs_poll) { | ||
| ASSERT(timer_cb_called == 2); | ||
| ASSERT(close_cb_called == 1); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -77,5 +77,6 @@ TEST_IMPL(idle_starvation) { | ||
| ASSERT(timer_cb_called == 1); | ||
| ASSERT(close_cb_called == 2); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -332,5 +332,6 @@ TEST_IMPL(loop_handles) { | ||
| ASSERT(idle_2_close_cb_called == idle_2_cb_started); | ||
| ASSERT(idle_2_is_active == 0); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -98,5 +98,6 @@ TEST_IMPL(multiple_listen) { | ||
| ASSERT(connect_cb_called == 1); | ||
| ASSERT(close_cb_called == 2); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -68,5 +68,6 @@ TEST_IMPL(poll_close) { | ||
|
|
||
| ASSERT(close_cb_called == NUM_SOCKETS); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -556,6 +556,8 @@ static void start_poll_test() { | ||
| spurious_writable_wakeups > 20); | ||
|
|
||
| ASSERT(closed_connections == NUM_CLIENTS * 2); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| } | ||
|
|
||
|
|
||
| @@ -44,5 +44,6 @@ TEST_IMPL(run_once) { | ||
| while (uv_run_once(uv_default_loop())); | ||
| ASSERT(idle_counter == NUM_TICKS); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -178,6 +178,7 @@ TEST_IMPL(shutdown_eof) { | ||
| ASSERT(called_timer_close_cb == 1); | ||
| ASSERT(called_timer_cb == 1); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
|
|
||
| @@ -0,0 +1,270 @@ | ||
| /* Copyright Joyent, Inc. and other Node contributors. All rights reserved. | ||
| * | ||
| * Permission is hereby granted, free of charge, to any person obtaining a copy | ||
| * of this software and associated documentation files (the "Software"), to | ||
| * deal in the Software without restriction, including without limitation the | ||
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | ||
| * sell copies of the Software, and to permit persons to whom the Software is | ||
| * furnished to do so, subject to the following conditions: | ||
| * | ||
| * The above copyright notice and this permission notice shall be included in | ||
| * all copies or substantial portions of the Software. | ||
| * | ||
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING | ||
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS | ||
| * IN THE SOFTWARE. | ||
| */ | ||
|
|
||
|
|
||
| /* This test does not pretend to be cross-platform. */ | ||
| #ifndef _WIN32 | ||
|
|
||
| #include "uv.h" | ||
| #include "task.h" | ||
|
|
||
| #include <errno.h> | ||
| #include <signal.h> | ||
| #include <stdarg.h> | ||
| #include <stdio.h> | ||
| #include <stdlib.h> | ||
| #include <string.h> | ||
| #include <unistd.h> | ||
|
|
||
|
|
||
| #define NUM_SIGNAL_HANDLING_THREADS 25 | ||
| #define NUM_LOOP_CREATING_THREADS 10 | ||
|
|
||
|
|
||
| static uv_sem_t sem; | ||
| static uv_mutex_t counter_lock; | ||
| static volatile int stop = 0; | ||
|
|
||
| static volatile int signal1_cb_counter = 0; | ||
| static volatile int signal2_cb_counter = 0; | ||
| static volatile int loop_creation_counter = 0; | ||
|
|
||
|
|
||
| static void increment_counter(volatile int* counter) { | ||
| uv_mutex_lock(&counter_lock); | ||
| ++(*counter); | ||
| uv_mutex_unlock(&counter_lock); | ||
| } | ||
|
|
||
|
|
||
| static void signal1_cb(uv_signal_t* handle, int signum) { | ||
| ASSERT(signum == SIGUSR1); | ||
| increment_counter(&signal1_cb_counter); | ||
| uv_signal_stop(handle); | ||
| } | ||
|
|
||
|
|
||
| static void signal2_cb(uv_signal_t* handle, int signum) { | ||
| ASSERT(signum == SIGUSR2); | ||
| increment_counter(&signal2_cb_counter); | ||
| uv_signal_stop(handle); | ||
| } | ||
|
|
||
|
|
||
| static void signal_handling_worker(void* context) { | ||
| uintptr_t mask = (uintptr_t) context; | ||
| uv_loop_t* loop; | ||
| uv_signal_t signal1a; | ||
| uv_signal_t signal1b; | ||
| uv_signal_t signal2; | ||
| int r; | ||
|
|
||
| loop = uv_loop_new(); | ||
| ASSERT(loop != NULL); | ||
|
|
||
| /* Setup the signal watchers and start them. */ | ||
| if (mask & SIGUSR1) { | ||
| r = uv_signal_init(loop, &signal1a); | ||
| ASSERT(r == 0); | ||
| r = uv_signal_start(&signal1a, signal1_cb, SIGUSR1); | ||
| ASSERT(r == 0); | ||
| r = uv_signal_init(loop, &signal1b); | ||
| ASSERT(r == 0); | ||
| r = uv_signal_start(&signal1b, signal1_cb, SIGUSR1); | ||
| ASSERT(r == 0); | ||
| } | ||
| if (mask & SIGUSR2) { | ||
| r = uv_signal_init(loop, &signal2); | ||
| ASSERT(r == 0); | ||
| r = uv_signal_start(&signal2, signal2_cb, SIGUSR2); | ||
| ASSERT(r == 0); | ||
| } | ||
|
|
||
| /* Signal watchers are now set up. */ | ||
| uv_sem_post(&sem); | ||
|
|
||
| /* Wait for all signals. The signal callbacks stop the watcher, so uv_run | ||
| * will return when all signal watchers caught a signal. | ||
| */ | ||
| r = uv_run(loop); | ||
| ASSERT(r == 0); | ||
|
|
||
| /* Restart the signal watchers. */ | ||
| if (mask & SIGUSR1) { | ||
| r = uv_signal_start(&signal1a, signal1_cb, SIGUSR1); | ||
| ASSERT(r == 0); | ||
| r = uv_signal_start(&signal1b, signal1_cb, SIGUSR1); | ||
| ASSERT(r == 0); | ||
| } | ||
| if (mask & SIGUSR2) { | ||
| r = uv_signal_start(&signal2, signal2_cb, SIGUSR2); | ||
| ASSERT(r == 0); | ||
| } | ||
|
|
||
| /* Wait for signals once more. */ | ||
| uv_sem_post(&sem); | ||
|
|
||
| r = uv_run(loop); | ||
| ASSERT(r == 0); | ||
|
|
||
| /* Close the watchers. */ | ||
| if (mask & SIGUSR1) { | ||
| uv_close((uv_handle_t*) &signal1a, NULL); | ||
| uv_close((uv_handle_t*) &signal1b, NULL); | ||
| } | ||
| if (mask & SIGUSR2) { | ||
| uv_close((uv_handle_t*) &signal2, NULL); | ||
| } | ||
|
|
||
| /* Wait for the signal watchers to close. */ | ||
| r = uv_run(loop); | ||
| ASSERT(r == 0); | ||
|
|
||
| uv_loop_delete(loop); | ||
| } | ||
|
|
||
|
|
||
| static void signal_unexpected_cb(uv_signal_t* handle, int signum) { | ||
| ASSERT(0 && "signal_unexpected_cb should never be called"); | ||
| } | ||
|
|
||
|
|
||
| static void loop_creating_worker(void* context) { | ||
| (void) context; | ||
|
|
||
| do { | ||
| uv_loop_t* loop; | ||
| uv_signal_t signal; | ||
| int r; | ||
|
|
||
| loop = uv_loop_new(); | ||
| ASSERT(loop != NULL); | ||
|
|
||
| r = uv_signal_init(loop, &signal); | ||
| ASSERT(r == 0); | ||
|
|
||
| r = uv_signal_start(&signal, signal_unexpected_cb, SIGTERM); | ||
| ASSERT(r == 0); | ||
|
|
||
| uv_close((uv_handle_t*) &signal, NULL); | ||
|
|
||
| r = uv_run(loop); | ||
| ASSERT(r == 0); | ||
|
|
||
| uv_loop_delete(loop); | ||
|
|
||
| increment_counter(&loop_creation_counter); | ||
| } while (!stop); | ||
| } | ||
|
|
||
|
|
||
| TEST_IMPL(signal_multiple_loops) { | ||
| int i, r; | ||
| uv_thread_t loop_creating_threads[NUM_LOOP_CREATING_THREADS]; | ||
| uv_thread_t signal_handling_threads[NUM_SIGNAL_HANDLING_THREADS]; | ||
| sigset_t sigset; | ||
|
|
||
| r = uv_sem_init(&sem, 0); | ||
| ASSERT(r == 0); | ||
|
|
||
| r = uv_mutex_init(&counter_lock); | ||
| ASSERT(r == 0); | ||
|
|
||
| /* Create a couple of threads that create a destroy loops continuously. */ | ||
| for (i = 0; i < NUM_LOOP_CREATING_THREADS; i++) { | ||
| r = uv_thread_create(&loop_creating_threads[i], | ||
| loop_creating_worker, | ||
| NULL); | ||
| ASSERT(r == 0); | ||
| } | ||
|
|
||
| /* Create a couple of threads that actually handle signals. */ | ||
| for (i = 0; i < NUM_SIGNAL_HANDLING_THREADS; i++) { | ||
| uintptr_t mask; | ||
|
|
||
| switch (i % 3) { | ||
| case 0: mask = SIGUSR1; break; | ||
| case 1: mask = SIGUSR2; break; | ||
| case 2: mask = SIGUSR1 | SIGUSR2; break; | ||
| } | ||
|
|
||
| r = uv_thread_create(&signal_handling_threads[i], | ||
| signal_handling_worker, | ||
| (void*) mask); | ||
| ASSERT(r == 0); | ||
| } | ||
|
|
||
| /* Wait until all threads have started and set up their signal watchers. */ | ||
| for (i = 0; i < NUM_SIGNAL_HANDLING_THREADS; i++) | ||
| uv_sem_wait(&sem); | ||
|
|
||
| r = kill(getpid(), SIGUSR1); | ||
| ASSERT(r == 0); | ||
| r = kill(getpid(), SIGUSR2); | ||
| ASSERT(r == 0); | ||
|
|
||
| /* Wait for all threads to handle these signals. */ | ||
| for (i = 0; i < NUM_SIGNAL_HANDLING_THREADS; i++) | ||
| uv_sem_wait(&sem); | ||
|
|
||
| /* Block all signals to this thread, so we are sure that from here the signal | ||
| * handler runs in another thread. This is is more likely to catch thread and | ||
| * signal safety issues if there are any. | ||
| */ | ||
| sigfillset(&sigset); | ||
| pthread_sigmask(SIG_SETMASK, &sigset, NULL); | ||
|
|
||
| r = kill(getpid(), SIGUSR1); | ||
| ASSERT(r == 0); | ||
| r = kill(getpid(), SIGUSR2); | ||
| ASSERT(r == 0); | ||
|
|
||
| /* Wait for all signal handling threads to exit. */ | ||
| for (i = 0; i < NUM_SIGNAL_HANDLING_THREADS; i++) { | ||
| r = uv_thread_join(&signal_handling_threads[i]); | ||
| ASSERT(r == 0); | ||
| } | ||
|
|
||
| /* Tell all loop creating threads to stop. */ | ||
| stop = 1; | ||
|
|
||
| /* Wait for all loop creating threads to exit. */ | ||
| for (i = 0; i < NUM_LOOP_CREATING_THREADS; i++) { | ||
| r = uv_thread_join(&loop_creating_threads[i]); | ||
| ASSERT(r == 0); | ||
| } | ||
|
|
||
| printf("signal1_cb calls: %d\n", signal1_cb_counter); | ||
| printf("signal2_cb calls: %d\n", signal2_cb_counter); | ||
| printf("loops created and destroyed: %d\n", loop_creation_counter); | ||
|
|
||
| ASSERT(signal1_cb_counter == 4 * NUM_SIGNAL_HANDLING_THREADS); | ||
| ASSERT(signal2_cb_counter == 2 * NUM_SIGNAL_HANDLING_THREADS); | ||
| /* We don't know exactly how much loops will be created and destroyed, but at | ||
| * least there should be 1 for every loop creating thread. | ||
| */ | ||
| ASSERT(loop_creation_counter >= NUM_LOOP_CREATING_THREADS); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
|
|
||
| #endif /* !_WIN32 */ |
| @@ -76,5 +76,6 @@ TEST_IMPL(tcp_close_while_connecting) { | ||
| ASSERT(timer1_cb_called == 1); | ||
| ASSERT(close_cb_called == 2); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -125,5 +125,6 @@ TEST_IMPL(tcp_close) { | ||
| ASSERT(write_cb_called == NUM_WRITE_REQS); | ||
| ASSERT(close_cb_called == 1); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -91,5 +91,6 @@ TEST_IMPL(tcp_connect_error_after_write) { | ||
| ASSERT(write_cb_called == 1); | ||
| ASSERT(close_cb_called == 1); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -66,5 +66,6 @@ TEST_IMPL(tcp_connect_error_fault) { | ||
| ASSERT(connect_cb_called == 0); | ||
| ASSERT(close_cb_called == 1); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -81,5 +81,6 @@ TEST_IMPL(tcp_connect_timeout) { | ||
| r = uv_run(uv_default_loop()); | ||
| ASSERT(r == 0); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -64,5 +64,6 @@ TEST_IMPL(tcp_connect6_error_fault) { | ||
| ASSERT(connect_cb_called == 0); | ||
| ASSERT(close_cb_called == 1); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -47,5 +47,6 @@ TEST_IMPL(tcp_flags) { | ||
| r = uv_run(loop); | ||
| ASSERT(r == 0); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -127,5 +127,6 @@ TEST_IMPL(tcp_shutdown_after_write) { | ||
| ASSERT(conn_close_cb_called == 1); | ||
| ASSERT(timer_close_cb_called == 1); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -109,5 +109,6 @@ TEST_IMPL(tcp_unexpected_read) { | ||
| */ | ||
| ASSERT(ticks <= 20); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -164,5 +164,6 @@ TEST_IMPL(tcp_write_error) { | ||
| ASSERT(write_cb_error_called >= 1); | ||
| ASSERT(tcp_client.write_queue_size == 0); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -131,5 +131,6 @@ TEST_IMPL(tcp_write_to_half_open_connection) { | ||
| ASSERT(write_cb_called > 0); | ||
| ASSERT(read_cb_called > 0); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -166,5 +166,6 @@ TEST_IMPL(tcp_writealot) { | ||
|
|
||
| free(send_buffer); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -53,5 +53,6 @@ TEST_IMPL(threadpool_queue_work_simple) { | ||
| ASSERT(work_cb_count == 1); | ||
| ASSERT(after_work_cb_count == 1); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -137,5 +137,6 @@ TEST_IMPL(timer_again) { | ||
| (long int)(uv_now(uv_default_loop()) - start_time)); | ||
| ASSERT(700 <= uv_now(uv_default_loop()) - start_time); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -106,5 +106,6 @@ TEST_IMPL(tty) { | ||
|
|
||
| uv_run(loop); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -82,5 +82,6 @@ TEST_IMPL(udp_dgram_too_big) { | ||
| ASSERT(send_cb_called == 1); | ||
| ASSERT(close_cb_called == 1); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -133,6 +133,8 @@ static void do_test(uv_udp_recv_cb recv_cb, int bind_flags) { | ||
| uv_run(uv_default_loop()); | ||
|
|
||
| ASSERT(close_cb_called == 3); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| } | ||
|
|
||
|
|
||
| @@ -135,5 +135,6 @@ TEST_IMPL(udp_multicast_join) { | ||
| ASSERT(sv_send_cb_called == 1); | ||
| ASSERT(close_cb_called == 2); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -82,5 +82,6 @@ TEST_IMPL(udp_multicast_ttl) { | ||
| ASSERT(sv_send_cb_called == 1); | ||
| ASSERT(close_cb_called == 1); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -82,5 +82,6 @@ TEST_IMPL(udp_options) { | ||
| r = uv_run(loop); | ||
| ASSERT(r == 0); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -204,5 +204,6 @@ TEST_IMPL(udp_send_and_recv) { | ||
| ASSERT(sv_recv_cb_called == 1); | ||
| ASSERT(close_cb_called == 2); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||
| @@ -73,5 +73,6 @@ TEST_IMPL(walk_handles) { | ||
| uv_walk(loop, walk_cb, magic_cookie); | ||
| ASSERT(seen_timer_handle == 0); | ||
|
|
||
| MAKE_VALGRIND_HAPPY(); | ||
| return 0; | ||
| } | ||