This is an automated email from the ASF dual-hosted git repository. toulmean pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/incubator-tuweni.git
The following commit(s) were added to refs/heads/master by this push: new 23724c6 Add more coverage of concurrent methods new 4a9105c Merge pull request #104 from atoulme/async_result_coverage 23724c6 is described below commit 23724c623a603a5c8d95081375aaa54644ee32ab Author: Antoine Toulme <anto...@lunar-ocean.com> AuthorDate: Sat Jun 27 15:10:34 2020 -0700 Add more coverage of concurrent methods --- concurrent/build.gradle | 2 + .../DefaultCompletableAsyncCompletionTest.java | 85 ++++++++++++++++++++++ .../DefaultCompletableAsyncResultTest.java | 52 +++++++++++++ 3 files changed, 139 insertions(+) diff --git a/concurrent/build.gradle b/concurrent/build.gradle index 4b38ec8..01ddd3f 100644 --- a/concurrent/build.gradle +++ b/concurrent/build.gradle @@ -16,9 +16,11 @@ dependencies { compile 'com.google.guava:guava' compileOnly 'io.vertx:vertx-core' + testCompile project(':junit') testCompile 'org.junit.jupiter:junit-jupiter-api' testCompile 'org.junit.jupiter:junit-jupiter-params' testCompile 'org.assertj:assertj-core' + testCompile 'io.vertx:vertx-core' testRuntime 'org.junit.jupiter:junit-jupiter-engine' } diff --git a/concurrent/src/test/java/org/apache/tuweni/concurrent/DefaultCompletableAsyncCompletionTest.java b/concurrent/src/test/java/org/apache/tuweni/concurrent/DefaultCompletableAsyncCompletionTest.java index ff67695..c86378d 100644 --- a/concurrent/src/test/java/org/apache/tuweni/concurrent/DefaultCompletableAsyncCompletionTest.java +++ b/concurrent/src/test/java/org/apache/tuweni/concurrent/DefaultCompletableAsyncCompletionTest.java @@ -14,16 +14,26 @@ package org.apache.tuweni.concurrent; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.fail; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.apache.tuweni.junit.VertxExtension; +import org.apache.tuweni.junit.VertxInstance; import java.util.Arrays; import java.util.Collection; import java.util.concurrent.CancellationException; import java.util.concurrent.CompletionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicReference; +import io.vertx.core.Vertx; +import io.vertx.core.WorkerExecutor; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +@ExtendWith(VertxExtension.class) class DefaultCompletableAsyncCompletionTest { @Test @@ -236,6 +246,21 @@ class DefaultCompletableAsyncCompletionTest { } @Test + void completesWhenAllInStreamComplete() { + CompletableAsyncCompletion completion1 = AsyncCompletion.incomplete(); + CompletableAsyncCompletion completion2 = AsyncCompletion.incomplete(); + Collection<AsyncCompletion> list = Arrays.asList(completion1, completion2); + + AsyncCompletion completion = AsyncCompletion.allOf(list.stream()); + assertThat(completion.isDone()).isFalse(); + + completion1.complete(); + assertThat(completion.isDone()).isFalse(); + completion2.complete(); + assertThat(completion.isDone()).isTrue(); + } + + @Test void completesWithExceptionWhenAnyInCollectionFail() throws Exception { CompletableAsyncCompletion completion1 = AsyncCompletion.incomplete(); CompletableAsyncCompletion completion2 = AsyncCompletion.incomplete(); @@ -271,6 +296,66 @@ class DefaultCompletableAsyncCompletionTest { assertThat(completedThrowable.get()).isInstanceOf(CancellationException.class); } + @Test + void testExecutingBlocking() throws InterruptedException { + AtomicReference<Boolean> executed = new AtomicReference<>(); + AsyncCompletion completion = AsyncCompletion.executeBlocking(() -> executed.set(true)); + completion.join(); + assertTrue(executed.get()); + } + + @Test + void testExecutingBlocking(@VertxInstance Vertx vertx) throws InterruptedException { + AtomicReference<Boolean> executed = new AtomicReference<>(); + AsyncCompletion completion = AsyncCompletion.executeBlocking(vertx, () -> executed.set(true)); + completion.join(); + assertTrue(executed.get()); + } + + @Test + void testRunOnContextSupplier(@VertxInstance Vertx vertx) throws InterruptedException { + AsyncCompletion completion = AsyncCompletion.runOnContext(vertx, AsyncCompletion::completed); + completion.join(); + } + + @Test + void testRunOnContext(@VertxInstance Vertx vertx) throws InterruptedException { + AtomicReference<Boolean> executed = new AtomicReference<>(); + AsyncCompletion completion = AsyncCompletion.runOnContext(vertx, () -> executed.set(true)); + completion.join(); + assertTrue(executed.get()); + } + + @Test + void testRunOnWorker(@VertxInstance Vertx vertx) throws InterruptedException { + AtomicReference<Boolean> executed = new AtomicReference<>(); + WorkerExecutor executor = vertx.createSharedWorkerExecutor("foo"); + AsyncCompletion completion = AsyncCompletion.executeBlocking(executor, () -> executed.set(true)); + completion.join(); + assertTrue(executed.get()); + } + + @Test + void testRunOnContextWithCompletion(@VertxInstance Vertx vertx) throws InterruptedException { + AtomicReference<Boolean> executed = new AtomicReference<>(); + AsyncCompletion completion = AsyncCompletion.runOnContext(vertx, () -> { + executed.set(true); + return AsyncCompletion.completed(); + }); + completion.join(); + assertTrue(executed.get()); + } + + @Test + void testRunOnExecutor() throws InterruptedException { + AtomicReference<Boolean> executed = new AtomicReference<>(); + ExecutorService service = Executors.newSingleThreadExecutor(); + AsyncCompletion completion = AsyncCompletion.executeBlocking(service, () -> executed.set(true)); + completion.join(); + assertTrue(executed.get()); + service.shutdown(); + } + private void assertCompletedWithException(AsyncCompletion completion, Exception exception) throws Exception { try { completion.join(); diff --git a/concurrent/src/test/java/org/apache/tuweni/concurrent/DefaultCompletableAsyncResultTest.java b/concurrent/src/test/java/org/apache/tuweni/concurrent/DefaultCompletableAsyncResultTest.java index 5d8b135..f82a73b 100644 --- a/concurrent/src/test/java/org/apache/tuweni/concurrent/DefaultCompletableAsyncResultTest.java +++ b/concurrent/src/test/java/org/apache/tuweni/concurrent/DefaultCompletableAsyncResultTest.java @@ -14,17 +14,27 @@ package org.apache.tuweni.concurrent; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNull; +import org.apache.tuweni.junit.VertxExtension; +import org.apache.tuweni.junit.VertxInstance; + import java.util.Arrays; import java.util.Collection; import java.util.List; import java.util.concurrent.CancellationException; import java.util.concurrent.CompletionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; import java.util.concurrent.atomic.AtomicReference; +import io.vertx.core.Vertx; +import io.vertx.core.WorkerExecutor; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +@ExtendWith(VertxExtension.class) class DefaultCompletableAsyncResultTest { @Test @@ -188,6 +198,48 @@ class DefaultCompletableAsyncResultTest { assertThat(completedThrowable.get()).isInstanceOf(CancellationException.class); } + + @Test + void testExecutingBlocking() throws InterruptedException { + AsyncResult<String> result = AsyncResult.executeBlocking(() -> "foo"); + assertEquals("foo", result.get()); + } + + @Test + void testExecutingBlocking(@VertxInstance Vertx vertx) throws InterruptedException { + AsyncResult<String> result = AsyncResult.executeBlocking(vertx, () -> "foo"); + assertEquals("foo", result.get()); + } + + @Test + void testRunOnContext(@VertxInstance Vertx vertx) throws InterruptedException { + AsyncResult<String> result = AsyncResult.runOnContext(vertx, () -> AsyncResult.completed("foo")); + assertEquals("foo", result.get()); + } + + @Test + void testRunOnExecutor() throws InterruptedException { + AtomicReference<Boolean> executed = new AtomicReference<>(); + ExecutorService service = Executors.newSingleThreadExecutor(); + AsyncResult<String> result = AsyncResult.executeBlocking(service, () -> "foo"); + assertEquals("foo", result.get()); + service.shutdown(); + } + + @Test + void testRunOnWorker(@VertxInstance Vertx vertx) throws InterruptedException { + AtomicReference<Boolean> executed = new AtomicReference<>(); + WorkerExecutor executor = vertx.createSharedWorkerExecutor("foo"); + AsyncResult<String> result = AsyncResult.executeBlocking(executor, () -> "foo"); + assertEquals("foo", result.get()); + } + + @Test + void testRunOnContextWithCompletion(@VertxInstance Vertx vertx) throws InterruptedException { + AsyncResult<String> result = AsyncResult.runOnContext(vertx, () -> AsyncResult.completed("foo")); + assertEquals("foo", result.get()); + } + private void assertCompletedWithException(AsyncResult<?> asyncResult, Exception exception) throws Exception { try { asyncResult.get(); --------------------------------------------------------------------- To unsubscribe, e-mail: commits-unsubscr...@tuweni.apache.org For additional commands, e-mail: commits-h...@tuweni.apache.org