ext/libuv/test/test-ping-pong.c in libuv-0.10.2 vs ext/libuv/test/test-ping-pong.c in libuv-0.10.3

@@ -46,12 +46,13 @@
   uv_connect_t connect_req;
   char read_buffer[BUFSIZE];
 } pinger_t;
 
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
-  return uv_buf_init(malloc(size), size);
+static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
+  buf->base = malloc(size);
+  buf->len = size;
 }
 
 
 static void pinger_on_close(uv_handle_t* handle) {
   pinger_t* pinger = (pinger_t*)handle->data;
@@ -75,38 +76,44 @@
   uv_buf_t buf;
 
   buf = uv_buf_init(PING, sizeof(PING) - 1);
 
   req = malloc(sizeof(*req));
-  if (uv_write(req, (uv_stream_t*)&pinger->stream.tcp, &buf, 1, pinger_after_write)) {
+  if (uv_write(req,
+               (uv_stream_t*) &pinger->stream.tcp,
+               &buf,
+               1,
+               pinger_after_write)) {
     FATAL("uv_write failed");
   }
 
   puts("PING");
 }
 
 
-static void pinger_read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
+static void pinger_read_cb(uv_stream_t* stream,
+                           ssize_t nread,
+                           const uv_buf_t* buf) {
   ssize_t i;
   pinger_t* pinger;
 
   pinger = (pinger_t*)stream->data;
 
   if (nread < 0) {
     ASSERT(nread == UV_EOF);
 
     puts("got EOF");
-    free(buf.base);
+    free(buf->base);
 
     uv_close((uv_handle_t*)(&pinger->stream.tcp), pinger_on_close);
 
     return;
   }
 
   /* Now we count the pings */
   for (i = 0; i < nread; i++) {
-    ASSERT(buf.base[i] == PING[pinger->state]);
+    ASSERT(buf->base[i] == PING[pinger->state]);
     pinger->state = (pinger->state + 1) % (sizeof(PING) - 1);
 
     if (pinger->state != 0)
       continue;
 
@@ -119,74 +126,80 @@
       uv_close((uv_handle_t*)(&pinger->stream.tcp), pinger_on_close);
       break;
     }
   }
 
-  free(buf.base);
+  free(buf->base);
 }
 
 
 static void pinger_on_connect(uv_connect_t *req, int status) {
   pinger_t *pinger = (pinger_t*)req->handle->data;
 
   pinger_on_connect_count++;
 
   ASSERT(status == 0);
 
-  ASSERT(uv_is_readable(req->handle));
-  ASSERT(uv_is_writable(req->handle));
-  ASSERT(!uv_is_closing((uv_handle_t *)req->handle));
+  ASSERT(1 == uv_is_readable(req->handle));
+  ASSERT(1 == uv_is_writable(req->handle));
+  ASSERT(0 == uv_is_closing((uv_handle_t *) req->handle));
 
   pinger_write_ping(pinger);
 
   uv_read_start((uv_stream_t*)(req->handle), alloc_cb, pinger_read_cb);
 }
 
 
 /* same ping-pong test, but using IPv6 connection */
 static void tcp_pinger_v6_new(void) {
   int r;
-  struct sockaddr_in6 server_addr = uv_ip6_addr("::1", TEST_PORT);
+  struct sockaddr_in6 server_addr;
   pinger_t *pinger;
 
-  pinger = (pinger_t*)malloc(sizeof(*pinger));
+  ASSERT(0 ==uv_ip6_addr("::1", TEST_PORT, &server_addr));
+  pinger = malloc(sizeof(*pinger));
   pinger->state = 0;
   pinger->pongs = 0;
 
   /* Try to connect to the server and do NUM_PINGS ping-pongs. */
   r = uv_tcp_init(uv_default_loop(), &pinger->stream.tcp);
   pinger->stream.tcp.data = pinger;
   ASSERT(!r);
 
   /* We are never doing multiple reads/connects at a time anyway. */
   /* so these handles can be pre-initialized. */
-  r = uv_tcp_connect6(&pinger->connect_req, &pinger->stream.tcp, server_addr,
-      pinger_on_connect);
+  r = uv_tcp_connect(&pinger->connect_req,
+                     &pinger->stream.tcp,
+                     (const struct sockaddr*) &server_addr,
+                     pinger_on_connect);
   ASSERT(!r);
 
   /* Synchronous connect callbacks are not allowed. */
   ASSERT(pinger_on_connect_count == 0);
 }
 
 
 static void tcp_pinger_new(void) {
   int r;
-  struct sockaddr_in server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  struct sockaddr_in server_addr;
   pinger_t *pinger;
 
-  pinger = (pinger_t*)malloc(sizeof(*pinger));
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
+  pinger = malloc(sizeof(*pinger));
   pinger->state = 0;
   pinger->pongs = 0;
 
   /* Try to connect to the server and do NUM_PINGS ping-pongs. */
   r = uv_tcp_init(uv_default_loop(), &pinger->stream.tcp);
   pinger->stream.tcp.data = pinger;
   ASSERT(!r);
 
   /* We are never doing multiple reads/connects at a time anyway. */
   /* so these handles can be pre-initialized. */
-  r = uv_tcp_connect(&pinger->connect_req, &pinger->stream.tcp, server_addr,
-      pinger_on_connect);
+  r = uv_tcp_connect(&pinger->connect_req,
+                     &pinger->stream.tcp,
+                     (const struct sockaddr*) &server_addr,
+                     pinger_on_connect);
   ASSERT(!r);
 
   /* Synchronous connect callbacks are not allowed. */
   ASSERT(pinger_on_connect_count == 0);
 }