Refine search
@Test public void testMapRemoveIfPresentBuffer() { testMapRemoveIfPresent(randomBuffer(4), randomBuffer(12), randomBuffer(14)); }
@Test public void testMapReplaceBuffer() { testMapReplace(randomBuffer(4), randomBuffer(12), randomBuffer(14)); }
@Test public void testMapReplaceIfPresentBuffer() { testMapReplaceIfPresent(randomBuffer(4), randomBuffer(12), randomBuffer(14)); }
@Test public void testMapPutIfAbsentGetBuffer() { testMapPutIfAbsentGet(randomBuffer(4), randomBuffer(12)); }
@Test public void testMapRemoveBuffer() { testMapRemove(randomBuffer(4), randomBuffer(12)); }
@Test public void testMapPutGetBuffer() { testMapPutGet(randomBuffer(4), randomBuffer(12)); }
@Test public void testReplyBuffer() { Buffer sent = TestUtils.randomBuffer(100); testReply(sent, (bytes) -> { assertEquals(sent, bytes); assertFalse(sent == bytes); // Make sure it's copied }); }
@Test public void testPublishBuffer() { Buffer sent = TestUtils.randomBuffer(100); testPublish(sent, (buffer) -> { assertEquals(sent, buffer); assertFalse(sent == buffer); // Make sure it's copied }); }
@Test public void testSendBuffer() { Buffer sent = TestUtils.randomBuffer(100); testSend(sent, (buffer) -> { assertEquals(sent, buffer); assertFalse(sent == buffer); // Make sure it's copied }); }
@Test public void testEchoBytes() { Buffer sent = TestUtils.randomBuffer(100); testEcho(sock -> sock.write(sent), buff -> assertEquals(sent, buff), sent.length()); }
@Test public void testRequestBodyBufferAtEnd() { Buffer body = TestUtils.randomBuffer(1000); server.requestHandler(req -> req.bodyHandler(buffer -> { assertEquals(body, buffer); req.response().end(); })); server.listen(onSuccess(server -> { client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete()).end(body); })); await(); }
@Test public void testResponseBodyBufferAtEnd() { Buffer body = TestUtils.randomBuffer(1000); server.requestHandler(req -> { req.response().end(body); }); server.listen(onSuccess(s -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.bodyHandler(buff -> { assertEquals(body, buff); testComplete(); }); })).end(); })); await(); }
@Test public void testDrainNotCalledAfterClose() throws Exception { String fileName = "some-file.dat"; vertx.fileSystem().open(testDir + pathSep + fileName, new OpenOptions(), onSuccess(file -> { Buffer buf = TestUtils.randomBuffer(1024 * 1024); file.write(buf); AtomicBoolean drainAfterClose = new AtomicBoolean(); file.drainHandler(v -> { drainAfterClose.set(true); }); file.close(ar -> { assertFalse(drainAfterClose.get()); testComplete(); }); })); await(); }
@Test public void testConnectionCloseDuringShouldCallHandleExceptionOnlyOnce() throws Exception { server.requestHandler(req -> { vertx.setTimer(500, id -> { req.connection().close(); }); }); AtomicInteger count = new AtomicInteger(); startServer(); HttpClientRequest post = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onFailure(res -> {})); post.setChunked(true); post.write(TestUtils.randomBuffer(10000)); CountDownLatch latch = new CountDownLatch(1); post.exceptionHandler(x-> { count.incrementAndGet(); vertx.setTimer(10, id -> { latch.countDown(); }); }); // then stall until timeout and the exception handler will be called. awaitLatch(latch); assertEquals(count.get(), 1); }
@Test public void testClientConnectionClose() throws Exception { // Test client connection close + server close handler CountDownLatch latch = new CountDownLatch(1); server.requestHandler(req -> { AtomicInteger len = new AtomicInteger(); req.handler(buff -> { if (len.addAndGet(buff.length()) == 1024) { latch.countDown(); } }); req.connection().closeHandler(v -> { testComplete(); }); }); CountDownLatch listenLatch = new CountDownLatch(1); server.listen(onSuccess(s -> listenLatch.countDown())); awaitLatch(listenLatch); HttpClientRequest req = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onFailure(err -> {})); req.setChunked(true); req.write(TestUtils.randomBuffer(1024)); awaitLatch(latch); req.connection().close(); await(); }
@Test public void testCopy() throws Exception { Buffer buff = TestUtils.randomBuffer(100); assertEquals(buff, buff.copy()); Buffer copy = buff.getBuffer(0, buff.length()); assertEquals(buff, copy); //Make sure they don't share underlying buffer Buffer copy2 = buff.copy(); buff.setInt(0, 1); assertEquals(copy, copy2); }
@Test public void testPauseResumeServerRequestFromAnotherThread() throws Exception { ExecutorService exec = Executors.newSingleThreadExecutor(); Buffer buffer = TestUtils.randomBuffer(64 * 1024 * 1024); Buffer readBuffer = Buffer.buffer(64 * 1024 * 1024); server.requestHandler(request -> {
@Test public void testResponseWrite() { Buffer body = TestUtils.randomBuffer(1000); server.requestHandler(req -> { req.response().setChunked(true); req.response().write(body); req.response().end(); }); server.listen(onSuccess(s -> { client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.bodyHandler(buff -> { assertEquals(body, buff); testComplete(); }); })).end(); })); await(); }
@Test public void testSendReceive() { peer1 = vertx.createDatagramSocket(new DatagramSocketOptions()); peer2 = vertx.createDatagramSocket(new DatagramSocketOptions()); peer2.exceptionHandler(t -> fail(t.getMessage())); peer2.listen(1234, "127.0.0.1", ar -> { assertTrue(ar.succeeded()); Buffer buffer = TestUtils.randomBuffer(128); peer2.handler(packet -> { assertFalse(Thread.holdsLock(peer2)); Buffer data = packet.data(); ByteBuf buff = data.getByteBuf(); while (buff != buff.unwrap() && buff.unwrap() != null) { buff = buff.unwrap(); } assertTrue("Was expecting an unpooled buffer instead of " + buff.getClass().getSimpleName(), buff.getClass().getSimpleName().contains("Unpooled")); assertEquals(buffer, data); testComplete(); }); peer1.send(buffer, 1234, "127.0.0.1", ar2 -> { assertFalse(Thread.holdsLock(peer1)); assertTrue(ar2.succeeded()); }); }); await(); }
@Test public void testResponseDataTimeout() { Buffer expected = TestUtils.randomBuffer(1000); server.requestHandler(req -> { req.response().setChunked(true).write(expected); }); server.listen(onSuccess(s -> { Buffer received = Buffer.buffer(); HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.request().setTimeout(500); resp.handler(received::appendBuffer); })); AtomicInteger count = new AtomicInteger(); req.exceptionHandler(t -> { if (count.getAndIncrement() == 0) { assertTrue(t instanceof TimeoutException); assertEquals(expected, received); testComplete(); } }); req.sendHead(); })); await(); }