diff --git a/test/benchmark-getaddrinfo.c b/test/benchmark-getaddrinfo.c
index c7f99a2f..1dbc23dd 100644
--- a/test/benchmark-getaddrinfo.c
+++ b/test/benchmark-getaddrinfo.c
@@ -83,8 +83,9 @@ BENCHMARK_IMPL(getaddrinfo) {
   ASSERT(calls_initiated == TOTAL_CALLS);
   ASSERT(calls_completed == TOTAL_CALLS);
 
-  LOGF("getaddrinfo: %.0f req/s\n",
-       (double) calls_completed / (double) (end_time - start_time) * 1000.0);
+  fprintf(stderr, "getaddrinfo: %.0f req/s\n",
+          (double) calls_completed / (double) (end_time - start_time) * 1000.0);
+  fflush(stderr);
 
   MAKE_VALGRIND_HAPPY();
   return 0;
diff --git a/test/benchmark-loop-count.c b/test/benchmark-loop-count.c
index 5cb81323..970a94c2 100644
--- a/test/benchmark-loop-count.c
+++ b/test/benchmark-loop-count.c
@@ -62,10 +62,11 @@ BENCHMARK_IMPL(loop_count) {
 
   ASSERT(ticks == NUM_TICKS);
 
-  LOGF("loop_count: %d ticks in %.2fs (%.0f/s)\n",
-       NUM_TICKS,
-       ns / 1e9,
-       NUM_TICKS / (ns / 1e9));
+  fprintf(stderr, "loop_count: %d ticks in %.2fs (%.0f/s)\n",
+          NUM_TICKS,
+          ns / 1e9,
+          NUM_TICKS / (ns / 1e9));
+  fflush(stderr);
 
   MAKE_VALGRIND_HAPPY();
   return 0;
@@ -83,7 +84,8 @@ BENCHMARK_IMPL(loop_count_timed) {
 
   uv_run(loop, UV_RUN_DEFAULT);
 
-  LOGF("loop_count: %lu ticks (%.0f ticks/s)\n", ticks, ticks / 5.0);
+  fprintf(stderr, "loop_count: %lu ticks (%.0f ticks/s)\n", ticks, ticks / 5.0);
+  fflush(stderr);
 
   MAKE_VALGRIND_HAPPY();
   return 0;
diff --git a/test/benchmark-million-timers.c b/test/benchmark-million-timers.c
index 6027d608..60a308be 100644
--- a/test/benchmark-million-timers.c
+++ b/test/benchmark-million-timers.c
@@ -75,10 +75,11 @@ BENCHMARK_IMPL(million_timers) {
   ASSERT(close_cb_called == NUM_TIMERS);
   free(timers);
 
-  LOGF("%.2f seconds total\n", (after_all - before_all) / 1e9);
-  LOGF("%.2f seconds init\n", (before_run - before_all) / 1e9);
-  LOGF("%.2f seconds dispatch\n", (after_run - before_run) / 1e9);
-  LOGF("%.2f seconds cleanup\n", (after_all - after_run) / 1e9);
+  fprintf(stderr, "%.2f seconds total\n", (after_all - before_all) / 1e9);
+  fprintf(stderr, "%.2f seconds init\n", (before_run - before_all) / 1e9);
+  fprintf(stderr, "%.2f seconds dispatch\n", (after_run - before_run) / 1e9);
+  fprintf(stderr, "%.2f seconds cleanup\n", (after_all - after_run) / 1e9);
+  fflush(stderr);
 
   MAKE_VALGRIND_HAPPY();
   return 0;
diff --git a/test/benchmark-ping-pongs.c b/test/benchmark-ping-pongs.c
index bb560d7d..646a7df9 100644
--- a/test/benchmark-ping-pongs.c
+++ b/test/benchmark-ping-pongs.c
@@ -80,7 +80,8 @@ static void pinger_close_cb(uv_handle_t* handle) {
   pinger_t* pinger;
 
   pinger = (pinger_t*)handle->data;
-  LOGF("ping_pongs: %d roundtrips/s\n", (1000 * pinger->pongs) / TIME);
+  fprintf(stderr, "ping_pongs: %d roundtrips/s\n", (1000 * pinger->pongs) / TIME);
+  fflush(stderr);
 
   free(pinger);
 
diff --git a/test/benchmark-pound.c b/test/benchmark-pound.c
index 58792854..79f36345 100644
--- a/test/benchmark-pound.c
+++ b/test/benchmark-pound.c
@@ -299,11 +299,12 @@ static int pound_it(int concurrency,
   /* Number of fractional seconds it took to run the benchmark. */
   secs = (double)(end_time - start_time) / NANOSEC;
 
-  LOGF("%s-conn-pound-%d: %.0f accepts/s (%d failed)\n",
-       type,
-       concurrency,
-       closed_streams / secs,
-       conns_failed);
+  fprintf(stderr, "%s-conn-pound-%d: %.0f accepts/s (%d failed)\n",
+          type,
+          concurrency,
+          closed_streams / secs,
+          conns_failed);
+  fflush(stderr);
 
   MAKE_VALGRIND_HAPPY();
   return 0;
diff --git a/test/benchmark-pump.c b/test/benchmark-pump.c
index d58f46a3..88f2dc5c 100644
--- a/test/benchmark-pump.c
+++ b/test/benchmark-pump.c
@@ -90,9 +90,10 @@ static void show_stats(uv_timer_t* handle) {
   int i;
 
 #if PRINT_STATS
-  LOGF("connections: %d, write: %.1f gbit/s\n",
-       write_sockets,
-       gbit(nsent, STATS_INTERVAL));
+  fprintf(stderr, "connections: %d, write: %.1f gbit/s\n",
+          write_sockets,
+          gbit(nsent, STATS_INTERVAL));
+  fflush(stderr);
 #endif
 
   /* Exit if the show is over */
@@ -101,10 +102,11 @@ static void show_stats(uv_timer_t* handle) {
     uv_update_time(loop);
     diff = uv_now(loop) - start_time;
 
-    LOGF("%s_pump%d_client: %.1f gbit/s\n",
-         type == TCP ? "tcp" : "pipe",
-         write_sockets,
-         gbit(nsent_total, diff));
+    fprintf(stderr, "%s_pump%d_client: %.1f gbit/s\n",
+            type == TCP ? "tcp" : "pipe",
+            write_sockets,
+            gbit(nsent_total, diff));
+    fflush(stderr);
 
     for (i = 0; i < write_sockets; i++) {
       if (type == TCP)
@@ -128,10 +130,11 @@ static void read_show_stats(void) {
   uv_update_time(loop);
   diff = uv_now(loop) - start_time;
 
-  LOGF("%s_pump%d_server: %.1f gbit/s\n",
-       type == TCP ? "tcp" : "pipe",
-       max_read_sockets,
-       gbit(nrecv_total, diff));
+  fprintf(stderr, "%s_pump%d_server: %.1f gbit/s\n",
+          type == TCP ? "tcp" : "pipe",
+          max_read_sockets,
+          gbit(nrecv_total, diff));
+  fflush(stderr);
 }
 
 
@@ -213,7 +216,10 @@ static void do_write(uv_stream_t* stream) {
 static void connect_cb(uv_connect_t* req, int status) {
   int i;
 
-  if (status) LOG(uv_strerror(status));
+  if (status) {
+    fprintf(stderr, "%s", uv_strerror(status));
+    fflush(stderr);
+  }
   ASSERT(status == 0);
 
   write_sockets++;
diff --git a/test/benchmark-sizes.c b/test/benchmark-sizes.c
index 8ccf10ee..9bf42f91 100644
--- a/test/benchmark-sizes.c
+++ b/test/benchmark-sizes.c
@@ -24,22 +24,23 @@
 
 
 BENCHMARK_IMPL(sizes) {
-  LOGF("uv_shutdown_t: %u bytes\n", (unsigned int) sizeof(uv_shutdown_t));
-  LOGF("uv_write_t: %u bytes\n", (unsigned int) sizeof(uv_write_t));
-  LOGF("uv_connect_t: %u bytes\n", (unsigned int) sizeof(uv_connect_t));
-  LOGF("uv_udp_send_t: %u bytes\n", (unsigned int) sizeof(uv_udp_send_t));
-  LOGF("uv_tcp_t: %u bytes\n", (unsigned int) sizeof(uv_tcp_t));
-  LOGF("uv_pipe_t: %u bytes\n", (unsigned int) sizeof(uv_pipe_t));
-  LOGF("uv_tty_t: %u bytes\n", (unsigned int) sizeof(uv_tty_t));
-  LOGF("uv_prepare_t: %u bytes\n", (unsigned int) sizeof(uv_prepare_t));
-  LOGF("uv_check_t: %u bytes\n", (unsigned int) sizeof(uv_check_t));
-  LOGF("uv_idle_t: %u bytes\n", (unsigned int) sizeof(uv_idle_t));
-  LOGF("uv_async_t: %u bytes\n", (unsigned int) sizeof(uv_async_t));
-  LOGF("uv_timer_t: %u bytes\n", (unsigned int) sizeof(uv_timer_t));
-  LOGF("uv_fs_poll_t: %u bytes\n", (unsigned int) sizeof(uv_fs_poll_t));
-  LOGF("uv_fs_event_t: %u bytes\n", (unsigned int) sizeof(uv_fs_event_t));
-  LOGF("uv_process_t: %u bytes\n", (unsigned int) sizeof(uv_process_t));
-  LOGF("uv_poll_t: %u bytes\n", (unsigned int) sizeof(uv_poll_t));
-  LOGF("uv_loop_t: %u bytes\n", (unsigned int) sizeof(uv_loop_t));
+  fprintf(stderr, "uv_shutdown_t: %u bytes\n", (unsigned int) sizeof(uv_shutdown_t));
+  fprintf(stderr, "uv_write_t: %u bytes\n", (unsigned int) sizeof(uv_write_t));
+  fprintf(stderr, "uv_connect_t: %u bytes\n", (unsigned int) sizeof(uv_connect_t));
+  fprintf(stderr, "uv_udp_send_t: %u bytes\n", (unsigned int) sizeof(uv_udp_send_t));
+  fprintf(stderr, "uv_tcp_t: %u bytes\n", (unsigned int) sizeof(uv_tcp_t));
+  fprintf(stderr, "uv_pipe_t: %u bytes\n", (unsigned int) sizeof(uv_pipe_t));
+  fprintf(stderr, "uv_tty_t: %u bytes\n", (unsigned int) sizeof(uv_tty_t));
+  fprintf(stderr, "uv_prepare_t: %u bytes\n", (unsigned int) sizeof(uv_prepare_t));
+  fprintf(stderr, "uv_check_t: %u bytes\n", (unsigned int) sizeof(uv_check_t));
+  fprintf(stderr, "uv_idle_t: %u bytes\n", (unsigned int) sizeof(uv_idle_t));
+  fprintf(stderr, "uv_async_t: %u bytes\n", (unsigned int) sizeof(uv_async_t));
+  fprintf(stderr, "uv_timer_t: %u bytes\n", (unsigned int) sizeof(uv_timer_t));
+  fprintf(stderr, "uv_fs_poll_t: %u bytes\n", (unsigned int) sizeof(uv_fs_poll_t));
+  fprintf(stderr, "uv_fs_event_t: %u bytes\n", (unsigned int) sizeof(uv_fs_event_t));
+  fprintf(stderr, "uv_process_t: %u bytes\n", (unsigned int) sizeof(uv_process_t));
+  fprintf(stderr, "uv_poll_t: %u bytes\n", (unsigned int) sizeof(uv_poll_t));
+  fprintf(stderr, "uv_loop_t: %u bytes\n", (unsigned int) sizeof(uv_loop_t));
+  fflush(stderr);
   return 0;
 }
diff --git a/test/benchmark-spawn.c b/test/benchmark-spawn.c
index 9cae41a8..ed9ad608 100644
--- a/test/benchmark-spawn.c
+++ b/test/benchmark-spawn.c
@@ -155,8 +155,9 @@ BENCHMARK_IMPL(spawn) {
   uv_update_time(loop);
   end_time = uv_now(loop);
 
-  LOGF("spawn: %.0f spawns/s\n",
-       (double) N / (double) (end_time - start_time) * 1000.0);
+  fprintf(stderr, "spawn: %.0f spawns/s\n",
+          (double) N / (double) (end_time - start_time) * 1000.0);
+  fflush(stderr);
 
   MAKE_VALGRIND_HAPPY();
   return 0;
diff --git a/test/run-benchmarks.c b/test/run-benchmarks.c
index 8d4f5497..6e42623d 100644
--- a/test/run-benchmarks.c
+++ b/test/run-benchmarks.c
@@ -41,7 +41,8 @@ int main(int argc, char **argv) {
   case 2: return maybe_run_test(argc, argv);
   case 3: return run_test_part(argv[1], argv[2]);
   default:
-    LOGF("Too many arguments.\n");
+    fprintf(stderr, "Too many arguments.\n");
+    fflush(stderr);
     return EXIT_FAILURE;
   }
 
diff --git a/test/run-tests.c b/test/run-tests.c
index e92c9300..1f458745 100644
--- a/test/run-tests.c
+++ b/test/run-tests.c
@@ -56,7 +56,8 @@ int main(int argc, char **argv) {
   case 2: return maybe_run_test(argc, argv);
   case 3: return run_test_part(argv[1], argv[2]);
   default:
-    LOGF("Too many arguments.\n");
+    fprintf(stderr, "Too many arguments.\n");
+    fflush(stderr);
     return EXIT_FAILURE;
   }
 
diff --git a/test/runner.c b/test/runner.c
index e896d43b..e094defc 100644
--- a/test/runner.c
+++ b/test/runner.c
@@ -43,13 +43,14 @@ static void log_progress(int total,
     total = 1;
 
   progress = 100 * (passed + failed + skipped + todos) / total;
-  LOGF("[%% %3d|+ %3d|- %3d|T %3d|S %3d]: %s",
-       progress,
-       passed,
-       failed,
-       todos,
-       skipped,
-       name);
+  fprintf(stderr, "[%% %3d|+ %3d|- %3d|T %3d|S %3d]: %s",
+          progress,
+          passed,
+          failed,
+          todos,
+          skipped,
+          name);
+  fflush(stderr);
 }
 
 
@@ -109,7 +110,8 @@ int run_tests(int benchmark_output) {
   }
 
   if (tap_output) {
-    LOGF("1..%d\n", total);
+    fprintf(stderr, "1..%d\n", total);
+    fflush(stderr);
   }
 
   /* Run all tests. */
@@ -184,7 +186,8 @@ void log_tap_result(int test_count,
     reason[0] = '\0';
   }
 
-  LOGF("%s %d - %s%s%s\n", result, test_count, test, directive, reason);
+  fprintf(stderr, "%s %d - %s%s%s\n", result, test_count, test, directive, reason);
+  fflush(stderr);
 }
 
 
@@ -320,49 +323,55 @@ out:
   /* Show error and output from processes if the test failed. */
   if (status != 0 || task->show_output) {
     if (tap_output) {
-      LOGF("#");
+      fprintf(stderr, "#");
     } else if (status == TEST_TODO) {
-      LOGF("\n`%s` todo\n", test);
+      fprintf(stderr, "\n`%s` todo\n", test);
     } else if (status == TEST_SKIP) {
-      LOGF("\n`%s` skipped\n", test);
+      fprintf(stderr, "\n`%s` skipped\n", test);
     } else if (status != 0) {
-      LOGF("\n`%s` failed: %s\n", test, errmsg);
+      fprintf(stderr, "\n`%s` failed: %s\n", test, errmsg);
     } else {
-      LOGF("\n");
+      fprintf(stderr, "\n");
     }
+    fflush(stderr);
 
     for (i = 0; i < process_count; i++) {
       switch (process_output_size(&processes[i])) {
        case -1:
-        LOGF("Output from process `%s`: (unavailable)\n",
-             process_get_name(&processes[i]));
+        fprintf(stderr, "Output from process `%s`: (unavailable)\n",
+                process_get_name(&processes[i]));
+        fflush(stderr);
         break;
 
        case 0:
-        LOGF("Output from process `%s`: (no output)\n",
-             process_get_name(&processes[i]));
+        fprintf(stderr, "Output from process `%s`: (no output)\n",
+                process_get_name(&processes[i]));
+        fflush(stderr);
         break;
 
        default:
-        LOGF("Output from process `%s`:\n", process_get_name(&processes[i]));
+        fprintf(stderr, "Output from process `%s`:\n", process_get_name(&processes[i]));
+        fflush(stderr);
         process_copy_output(&processes[i], fileno(stderr));
         break;
       }
     }
 
     if (!tap_output) {
-      LOG("=============================================================\n");
+      fprintf(stderr, "=============================================================\n");
     }
 
   /* In benchmark mode show concise output from the main process. */
   } else if (benchmark_output) {
     switch (process_output_size(main_proc)) {
      case -1:
-      LOGF("%s: (unavailable)\n", test);
+      fprintf(stderr, "%s: (unavailable)\n", test);
+      fflush(stderr);
       break;
 
      case 0:
-      LOGF("%s: (no output)\n", test);
+      fprintf(stderr, "%s: (no output)\n", test);
+      fflush(stderr);
       break;
 
      default:
@@ -397,7 +406,8 @@ int run_test_part(const char* test, const char* part) {
     }
   }
 
-  LOGF("No test part with that name: %s:%s\n", test, part);
+  fprintf(stderr, "No test part with that name: %s:%s\n", test, part);
+  fflush(stderr);
   return 255;
 }
 
diff --git a/test/task.h b/test/task.h
index 07584c52..646109e7 100644
--- a/test/task.h
+++ b/test/task.h
@@ -76,19 +76,6 @@ typedef enum {
   PIPE
 } stream_type;
 
-/* Log to stderr. */
-#define LOG(...)                        \
-  do {                                  \
-    fprintf(stderr, "%s", __VA_ARGS__); \
-    fflush(stderr);                     \
-  } while (0)
-
-#define LOGF(...)                       \
-  do {                                  \
-    fprintf(stderr, __VA_ARGS__);       \
-    fflush(stderr);                     \
-  } while (0)
-
 /* Die with fatal error. */
 #define FATAL(msg)                                        \
   do {                                                    \
@@ -158,13 +145,15 @@ enum test_status {
 
 #define RETURN_TODO(explanation)                                              \
   do {                                                                        \
-    LOGF("%s\n", explanation);                                                \
+    fprintf(stderr, "%s\n", explanation);                                     \
+    fflush(stderr);                                                           \
     return TEST_TODO;                                                         \
   } while (0)
 
 #define RETURN_SKIP(explanation)                                              \
   do {                                                                        \
-    LOGF("%s\n", explanation);                                                \
+    fprintf(stderr, "%s\n", explanation);                                     \
+    fflush(stderr);                                                           \
     return TEST_SKIP;                                                         \
   } while (0)
 
diff --git a/test/test-handle-fileno.c b/test/test-handle-fileno.c
index df5e984a..3fe933ad 100644
--- a/test/test-handle-fileno.c
+++ b/test/test-handle-fileno.c
@@ -102,7 +102,8 @@ TEST_IMPL(handle_fileno) {
 
   tty_fd = get_tty_fd();
   if (tty_fd < 0) {
-    LOGF("Cannot open a TTY fd");
+    fprintf(stderr, "Cannot open a TTY fd");
+    fflush(stderr);
   } else {
     r = uv_tty_init(loop, &tty, tty_fd, 0);
     ASSERT(r == 0);
diff --git a/test/test-idle.c b/test/test-idle.c
index 0e991c36..f49d1964 100644
--- a/test/test-idle.c
+++ b/test/test-idle.c
@@ -46,7 +46,8 @@ static void timer_cb(uv_timer_t* handle) {
   uv_close((uv_handle_t*) &timer_handle, close_cb);
 
   timer_cb_called++;
-  LOGF("timer_cb %d\n", timer_cb_called);
+  fprintf(stderr, "timer_cb %d\n", timer_cb_called);
+  fflush(stderr);
 }
 
 
@@ -54,7 +55,8 @@ static void idle_cb(uv_idle_t* handle) {
   ASSERT(handle == &idle_handle);
 
   idle_cb_called++;
-  LOGF("idle_cb %d\n", idle_cb_called);
+  fprintf(stderr, "idle_cb %d\n", idle_cb_called);
+  fflush(stderr);
 }
 
 
@@ -62,7 +64,8 @@ static void check_cb(uv_check_t* handle) {
   ASSERT(handle == &check_handle);
 
   check_cb_called++;
-  LOGF("check_cb %d\n", check_cb_called);
+  fprintf(stderr, "check_cb %d\n", check_cb_called);
+  fflush(stderr);
 }
 
 
diff --git a/test/test-ip6-addr.c b/test/test-ip6-addr.c
index cf8491fb..869b099e 100644
--- a/test/test-ip6-addr.c
+++ b/test/test-ip6-addr.c
@@ -77,14 +77,16 @@ TEST_IMPL(ip6_addr_link_local) {
              device_name);
 #endif
 
-    LOGF("Testing link-local address %s "
-         "(iface_index: 0x%02x, device_name: %s)\n",
-         scoped_addr,
-         iface_index,
-         device_name);
+    fprintf(stderr, "Testing link-local address %s "
+            "(iface_index: 0x%02x, device_name: %s)\n",
+            scoped_addr,
+            iface_index,
+            device_name);
+    fflush(stderr);
 
     ASSERT(0 == uv_ip6_addr(scoped_addr, TEST_PORT, &addr));
-    LOGF("Got scope_id 0x%02x\n", addr.sin6_scope_id);
+    fprintf(stderr, "Got scope_id 0x%02x\n", addr.sin6_scope_id);
+    fflush(stderr);
     ASSERT(iface_index == addr.sin6_scope_id);
   }
 
diff --git a/test/test-loop-handles.c b/test/test-loop-handles.c
index 0986de52..c3e8498a 100644
--- a/test/test-loop-handles.c
+++ b/test/test-loop-handles.c
@@ -113,7 +113,8 @@ static void timer_cb(uv_timer_t* handle) {
 
 
 static void idle_2_close_cb(uv_handle_t* handle) {
-  LOG("IDLE_2_CLOSE_CB\n");
+  fprintf(stderr, "%s", "IDLE_2_CLOSE_CB\n");
+  fflush(stderr);
 
   ASSERT(handle == (uv_handle_t*)&idle_2_handle);
 
@@ -125,7 +126,8 @@ static void idle_2_close_cb(uv_handle_t* handle) {
 
 
 static void idle_2_cb(uv_idle_t* handle) {
-  LOG("IDLE_2_CB\n");
+  fprintf(stderr, "%s", "IDLE_2_CB\n");
+  fflush(stderr);
 
   ASSERT(handle == &idle_2_handle);
 
@@ -138,7 +140,8 @@ static void idle_2_cb(uv_idle_t* handle) {
 static void idle_1_cb(uv_idle_t* handle) {
   int r;
 
-  LOG("IDLE_1_CB\n");
+  fprintf(stderr, "%s", "IDLE_1_CB\n");
+  fflush(stderr);
 
   ASSERT(handle != NULL);
   ASSERT(idles_1_active > 0);
@@ -164,7 +167,8 @@ static void idle_1_cb(uv_idle_t* handle) {
 
 
 static void idle_1_close_cb(uv_handle_t* handle) {
-  LOG("IDLE_1_CLOSE_CB\n");
+  fprintf(stderr, "%s", "IDLE_1_CLOSE_CB\n");
+  fflush(stderr);
 
   ASSERT(handle != NULL);
 
@@ -173,7 +177,8 @@ static void idle_1_close_cb(uv_handle_t* handle) {
 
 
 static void prepare_1_close_cb(uv_handle_t* handle) {
-  LOG("PREPARE_1_CLOSE_CB");
+  fprintf(stderr, "%s", "PREPARE_1_CLOSE_CB");
+  fflush(stderr);
   ASSERT(handle == (uv_handle_t*)&prepare_1_handle);
 
   prepare_1_close_cb_called++;
@@ -181,7 +186,8 @@ static void prepare_1_close_cb(uv_handle_t* handle) {
 
 
 static void check_close_cb(uv_handle_t* handle) {
-  LOG("CHECK_CLOSE_CB\n");
+  fprintf(stderr, "%s", "CHECK_CLOSE_CB\n");
+  fflush(stderr);
   ASSERT(handle == (uv_handle_t*)&check_handle);
 
   check_close_cb_called++;
@@ -189,7 +195,8 @@ static void check_close_cb(uv_handle_t* handle) {
 
 
 static void prepare_2_close_cb(uv_handle_t* handle) {
-  LOG("PREPARE_2_CLOSE_CB\n");
+  fprintf(stderr, "%s", "PREPARE_2_CLOSE_CB\n");
+  fflush(stderr);
   ASSERT(handle == (uv_handle_t*)&prepare_2_handle);
 
   prepare_2_close_cb_called++;
@@ -199,8 +206,8 @@ static void prepare_2_close_cb(uv_handle_t* handle) {
 static void check_cb(uv_check_t* handle) {
   int i, r;
 
-  LOG("CHECK_CB\n");
-
+  fprintf(stderr, "%s", "CHECK_CB\n");
+  fflush(stderr);
   ASSERT(handle == &check_handle);
 
   if (loop_iteration < ITERATIONS) {
@@ -235,8 +242,8 @@ static void check_cb(uv_check_t* handle) {
 static void prepare_2_cb(uv_prepare_t* handle) {
   int r;
 
-  LOG("PREPARE_2_CB\n");
-
+  fprintf(stderr, "%s", "PREPARE_2_CB\n");
+  fflush(stderr);
   ASSERT(handle == &prepare_2_handle);
 
   /* prepare_2 gets started by prepare_1 when (loop_iteration % 2 == 0), */
@@ -255,8 +262,8 @@ static void prepare_2_cb(uv_prepare_t* handle) {
 static void prepare_1_cb(uv_prepare_t* handle) {
   int r;
 
-  LOG("PREPARE_1_CB\n");
-
+  fprintf(stderr, "%s", "PREPARE_1_CB\n");
+  fflush(stderr);
   ASSERT(handle == &prepare_1_handle);
 
   if (loop_iteration % 2 == 0) {
diff --git a/test/test-osx-select.c b/test/test-osx-select.c
index 6ccf6034..a0afda91 100644
--- a/test/test-osx-select.c
+++ b/test/test-osx-select.c
@@ -39,6 +39,7 @@ static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
 
 static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) {
   fprintf(stdout, "got data %d\n", ++read_count);
+  fflush(stdout);
 
   if (read_count == 3)
     uv_close((uv_handle_t*) stream, NULL);
@@ -55,7 +56,8 @@ TEST_IMPL(osx_select) {
 
   fd = open("/dev/tty", O_RDONLY);
   if (fd < 0) {
-    LOGF("Cannot open /dev/tty as read-only: %s\n", strerror(errno));
+    fprintf(stderr, "Cannot open /dev/tty as read-only: %s\n", strerror(errno));
+    fflush(stderr);
     return TEST_SKIP;
   }
 
@@ -107,7 +109,8 @@ TEST_IMPL(osx_select_many_fds) {
 
   fd = open("/dev/tty", O_RDONLY);
   if (fd < 0) {
-    LOGF("Cannot open /dev/tty as read-only: %s\n", strerror(errno));
+    fprintf(stderr, "Cannot open /dev/tty as read-only: %s\n", strerror(errno));
+    fflush(stderr);
     return TEST_SKIP;
   }
 
diff --git a/test/test-timer-again.c b/test/test-timer-again.c
index 095cd9e7..f93c509b 100644
--- a/test/test-timer-again.c
+++ b/test/test-timer-again.c
@@ -47,8 +47,9 @@ static void repeat_1_cb(uv_timer_t* handle) {
   ASSERT(handle == &repeat_1);
   ASSERT(uv_timer_get_repeat((uv_timer_t*)handle) == 50);
 
-  LOGF("repeat_1_cb called after %ld ms\n",
-      (long int)(uv_now(uv_default_loop()) - start_time));
+  fprintf(stderr, "repeat_1_cb called after %ld ms\n",
+          (long int)(uv_now(uv_default_loop()) - start_time));
+  fflush(stderr);
 
   repeat_1_cb_called++;
 
@@ -69,8 +70,9 @@ static void repeat_2_cb(uv_timer_t* handle) {
   ASSERT(handle == &repeat_2);
   ASSERT(repeat_2_cb_allowed);
 
-  LOGF("repeat_2_cb called after %ld ms\n",
-      (long int)(uv_now(uv_default_loop()) - start_time));
+  fprintf(stderr, "repeat_2_cb called after %ld ms\n",
+          (long int)(uv_now(uv_default_loop()) - start_time));
+  fflush(stderr);
 
   repeat_2_cb_called++;
 
@@ -80,8 +82,9 @@ static void repeat_2_cb(uv_timer_t* handle) {
     return;
   }
 
-  LOGF("uv_timer_get_repeat %ld ms\n",
-      (long int)uv_timer_get_repeat(&repeat_2));
+  fprintf(stderr, "uv_timer_get_repeat %ld ms\n",
+          (long int)uv_timer_get_repeat(&repeat_2));
+  fflush(stderr);
   ASSERT(uv_timer_get_repeat(&repeat_2) == 100);
 
   /* This shouldn't take effect immediately. */
@@ -129,8 +132,9 @@ TEST_IMPL(timer_again) {
   ASSERT(repeat_2_cb_called == 2);
   ASSERT(close_cb_called == 2);
 
-  LOGF("Test took %ld ms (expected ~700 ms)\n",
-       (long int)(uv_now(uv_default_loop()) - start_time));
+  fprintf(stderr, "Test took %ld ms (expected ~700 ms)\n",
+          (long int)(uv_now(uv_default_loop()) - start_time));
+  fflush(stderr);
 
   MAKE_VALGRIND_HAPPY();
   return 0;
diff --git a/test/test-tty.c b/test/test-tty.c
index 7d0249a9..81e612c1 100644
--- a/test/test-tty.c
+++ b/test/test-tty.c
@@ -66,13 +66,15 @@ TEST_IMPL(tty) {
 #else /* unix */
   ttyin_fd = open("/dev/tty", O_RDONLY, 0);
   if (ttyin_fd < 0) {
-    LOGF("Cannot open /dev/tty as read-only: %s\n", strerror(errno));
+    fprintf(stderr, "Cannot open /dev/tty as read-only: %s\n", strerror(errno));
+    fflush(stderr);
     return TEST_SKIP;
   }
 
   ttyout_fd = open("/dev/tty", O_WRONLY, 0);
   if (ttyout_fd < 0) {
-    LOGF("Cannot open /dev/tty as write-only: %s\n", strerror(errno));
+    fprintf(stderr, "Cannot open /dev/tty as write-only: %s\n", strerror(errno));
+    fflush(stderr);
     return TEST_SKIP;
   }
 #endif