Improve tests

eclipse-vertx · Oct 29, 2018 · 200e281 · 200e281
1 parent b059104
commit 200e281
Show file tree

Hide file tree

Showing 2 changed files with 50 additions and 61 deletions.
diff --git a/src/test/java/io/vertx/core/http/Http2ServerTest.java b/src/test/java/io/vertx/core/http/Http2ServerTest.java
@@ -2276,14 +2276,7 @@ public void onHeadersRead(ChannelHandlerContext ctx, int streamId, Http2Headers
   @Test
   public void testNetSocketConnect() throws Exception {
     waitFor(2);
-    final AtomicInteger writeHandlerCounter = new AtomicInteger(0);
+    List<Integer> callbacks = Collections.synchronizedList(new ArrayList<>());
-    Handler<AsyncResult<Void>> writeHandler = (result) -> {
-      if(result.succeeded()) {
-        assertTrue(writeHandlerCounter.incrementAndGet() >= 1);
-      } else {
-        fail(result.cause());
-      }
-    };
 
     server.requestHandler(req -> {
       NetSocket socket = req.netSocket();
@@ -2292,7 +2285,7 @@ public void testNetSocketConnect() throws Exception {
         switch (status.getAndIncrement()) {
           case 0:
             assertEquals(Buffer.buffer("some-data"), buff);
-            socket.write(buff, writeHandler);
+            socket.write(buff, onSuccess(v2 -> callbacks.add(0)));
             break;
           case 1:
             assertEquals(Buffer.buffer("last-data"), buff);
@@ -2302,14 +2295,14 @@ public void testNetSocketConnect() throws Exception {
             break;
         }
       });
-      socket.endHandler(v -> {
+      socket.endHandler(v1 -> {
         assertEquals(2, status.getAndIncrement());
-        socket.write(Buffer.buffer("last-data"), writeHandler);
+        socket.write(Buffer.buffer("last-data"), onSuccess(v2 -> callbacks.add(1)));
       });
       socket.closeHandler(v -> {
-        assertEquals(3, status.getAndIncrement());
+        assertEquals(2, callbacks.size());
+        assertEquals(Arrays.asList(0, 1), callbacks);
         complete();
-        assertEquals(2, writeHandlerCounter.get());
       });
     });
 
@@ -2413,22 +2406,15 @@ public int onDataRead(ChannelHandlerContext ctx, int streamId, ByteBuf data, int
   @Test
   public void testServerCloseNetSocket() throws Exception {
     waitFor(2);
-    final AtomicInteger writeHandlerCounter = new AtomicInteger(0);
+    final AtomicInteger writeAcks = new AtomicInteger(0);
-    Handler<AsyncResult<Void>> writeHandler = (result) -> {
-      if(result.succeeded()) {
-        assertTrue(writeHandlerCounter.incrementAndGet() >= 1);
-      } else {
-        fail(result.cause());
-      }
-    };
     AtomicInteger status = new AtomicInteger();
     server.requestHandler(req -> {
       NetSocket socket = req.netSocket();
       socket.handler(buff -> {
         switch (status.getAndIncrement()) {
           case 0:
             assertEquals(Buffer.buffer("some-data"), buff);
-            socket.write(buff, writeHandler);
+            socket.write(buff, onSuccess(v -> writeAcks.incrementAndGet()));
             socket.close();
             break;
           case 1:
@@ -2445,7 +2431,7 @@ public void testServerCloseNetSocket() throws Exception {
       socket.closeHandler(v -> {
         assertEquals(3, status.getAndIncrement());
         complete();
-        assertEquals(1, writeHandlerCounter.get());
+        assertEquals(1, writeAcks.get());
       });
     });
 

diff --git a/src/test/java/io/vertx/core/net/NetTest.java b/src/test/java/io/vertx/core/net/NetTest.java
@@ -789,51 +789,54 @@ public void testSocketAddress() throws Exception {
   }
 
   @Test
-  public void testWriteHandlerSuccess() {
+  public void testWriteHandlerSuccess() throws Exception {
-    final AtomicInteger writeHandlerCounter = new AtomicInteger(0);
+    CompletableFuture<Void> close = new CompletableFuture<>();
-    Handler<AsyncResult<Void>> writeHandler = (v) -> {
+    server.connectHandler(socket -> {
-      if(v.succeeded()) {
+      socket.pause();
-        assertEquals(1, writeHandlerCounter.incrementAndGet());
+      close.thenAccept(v -> {
-      } else {
+        socket.resume();
-        fail(v.cause());
+      });
-      }
+    });
-      testComplete();
+    startServer();
-    };
+    client.connect(testAddress, onSuccess(so -> {
-    Buffer sent = TestUtils.randomBuffer(100);
+      writeUntilFull(so, v -> {
-    testEcho(sock -> sock.write(sent, writeHandler), buff -> assertEquals(sent, buff), sent.length());
+        so.write(Buffer.buffer("lost buffer"), onSuccess(ack -> testComplete()));
-    assertEquals(1, writeHandlerCounter.get());
+        close.complete(null);
+      });
+    }));
+    await();
   }
 
   @Test
-  public void testWriteHandlerFailure() {
+  public void testWriteHandlerFailure() throws Exception {
-    Handler<AsyncResult<Void>> writeHandler = (asyncResult) -> {
+    CompletableFuture<Void> close = new CompletableFuture<>();
-      assertFalse(asyncResult.succeeded());
+    server.connectHandler(socket -> {
-      assertTrue(asyncResult.failed());
-      testComplete();
-    };
-
-    Handler<AsyncResult<NetSocket>> clientHandler = (asyncResult) -> {
-      assert(asyncResult.succeeded());
-      NetSocket socket = asyncResult.result();
-      socket.handler(socket::write);
-      socket.setWriteQueueMaxSize(100);
-      Buffer sent = TestUtils.randomBuffer(1000);
-      socket.write(sent);
-      socket.write(sent);
-      assertTrue(socket.writeQueueFull());
-      socket.write(sent, writeHandler);
-    };
-
-    Handler<AsyncResult<NetServer>> listenHandler = s -> client.connect(testAddress, clientHandler);
-    Handler<NetSocket> serverHandler = socket -> {
       socket.pause();
-      socket.close();
+      close.thenAccept(v -> {
-    };
+        socket.close();
-
+      });
-    server.connectHandler(serverHandler).listen(testAddress, listenHandler);
+    });
+    startServer();
+    client.connect(testAddress, onSuccess(so -> {
+      writeUntilFull(so, v -> {
+        so.write(Buffer.buffer("lost buffer"), onFailure(err -> {
+          testComplete();
+        }));
+        close.complete(null);
+      });
+    }));
     await();
   }
 
+  private void writeUntilFull(NetSocket so, Handler<Void> handler) {
+    if (so.writeQueueFull()) {
+      handler.handle(null);
+    } else {
+      so.write(TestUtils.randomBuffer(256));
+      vertx.runOnContext(v -> writeUntilFull(so, handler));
+    }
+  }
+
   @Test
   public void testEchoBytes() {
     Buffer sent = TestUtils.randomBuffer(100);