如何使用JUnit测试异步流程

link管理

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

相关文章推荐

豪爽的香烟 · concurrent.futures -- ...· 3 月前 ·

绅士的炒饭 · jquery数据遍历动态添加到table_j ...· 1 年前 ·

乐观的炒饭 · pycharm导入talib的方法_pych ...· 2 年前 ·

无聊的莴苣 · 如何删除SQL ...· 2 年前 ·

叛逆的键盘 · javax.management.Insta ...· 2 年前 ·

含蓄的鞭炮 · Linux 下利用 gdb 查看 C++ ...· 2 年前 ·

腾讯云

开发者社区

文档意见反馈控制台

首页 TVP

文章/答案/技术大牛

发布

class Foo {
  private final Executor executor;
  public Foo(Executor executor) {
    this.executor = executor;
  public void doAsync(Callback c) {
    executor.execute(new Runnable() {
      @Override public void run() {
        // Do stuff here
        c.onComplete(data);
}

class SynchronousExecutor implements Executor {
  @Override public void execute(Runnable r) {
    r.run();
}

@Test public void testDoAsync() {
  Executor executor = new SynchronousExecutor();
  Foo objectToTest = new Foo(executor);
  Callback callback = mock(Callback.class);
  objectToTest.doAsync(callback);
  // Verify that Callback#onComplete was called using Mockito.
  verify(callback).onComplete(any(Data.class));
  // Assert that we got back the data that we expected.
  assertEquals(expectedData, callback.getData());
}

CompletableFuture<String> future = new CompletableFuture<>();
executorService.submit(new Runnable() {         
    @Override
    public void run() {
        future.complete("Hello World!");                
assertEquals("Hello World!", future.get());

@Test
public void test() throws Throwable {
    final boolean[] asyncExecuted = {false};
    final Throwable[] asyncThrowable= {null};
    // do anything async
    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                // Put your test here.
                fail(); 
            // lets inform the test thread that there is an error.
            catch (Throwable throwable){
                asyncThrowable[0] = throwable;
            // ensure to release asyncExecuted in case of error.
            finally {
                synchronized (asyncExecuted){
                    asyncExecuted[0] = true;
                    asyncExecuted.notify();
    }).start();
    // Waiting for the test is complete
    synchronized (asyncExecuted){
        while(!asyncExecuted[0]){
            asyncExecuted.wait();
    // get any async error, including exceptions and assertationErrors
    if(asyncThrowable[0] != null){
        throw asyncThrowable[0];
}

public class Example {
    private Dependency dependency;
    public Example(Dependency dependency) {
        this.dependency = dependency;            
    public CompletableFuture<String> someAsyncMethod(){
        return dependency.asyncMethod()
                .handle((r,ex) -> {
                    if(ex != null) {
                        return "got exception";
                    } else {
                        return r.toString();
public class Dependency {
    public CompletableFuture<Integer> asyncMethod() {
        // do some async stuff       
}

public class DependencyTest {
    private Example sut;
    private Dependency dependency;
    public void setup() {
        dependency = Mockito.mock(Dependency.class);;
        sut = new Example(dependency);
    @Test public void success() throws InterruptedException, ExecutionException {
        when(dependency.asyncMethod()).thenReturn(CompletableFuture.completedFuture(5));
        // When
        CompletableFuture<String> result = sut.someAsyncMethod();
        // Then
        assertThat(result.isCompletedExceptionally(), is(equalTo(false)));
        String value = result.get();
        assertThat(value, is(equalTo("5")));
    @Test public void failed() throws InterruptedException, ExecutionException {
        // Given
        CompletableFuture<Integer> c = new CompletableFuture<Integer>();
        c.completeExceptionally(new RuntimeException("failed"));
        when(dependency.asyncMethod()).thenReturn(c);
        // When
        CompletableFuture<String> result = sut.someAsyncMethod();
        // Then
        assertThat(result.isCompletedExceptionally(), is(equalTo(false)));
        String value = result.get();
        assertThat(value, is(equalTo("got exception")));
}

public class TestUtil {
    public static <R> R await(Consumer<CompletableFuture<R>> completer) {
        return await(20, TimeUnit.SECONDS, completer);
    public static <R> R await(int time, TimeUnit unit, Consumer<CompletableFuture<R>> completer) {
        CompletableFuture<R> f = new CompletableFuture<>();
        completer.accept(f);
        try {
            return f.get(time, unit);
        } catch (InterruptedException | TimeoutException e) {
            throw new RuntimeException("Future timed out", e);
        } catch (ExecutionException e) {
            throw new RuntimeException("Future failed", e.getCause());
}

    @Test
    public void testAsync() {
        String result = await(f -> {
            new Thread(() -> f.complete("My Result")).start();
        assertEquals("My Result", result);
    }

CompletableFuture.completedFuture("donzo")

this.exactly(2).of(mockEventHubClientWrapper).sendASync(with(any(LinkedList.class)));
this.will(returnValue(new CompletableFuture<>().completedFuture("donzo")));

CompletableFuture.allOf(calls.toArray(new CompletableFuture[0])).join();

    @Test(timeout = TIMEOUT)
public void message() throws URISyntaxException, InterruptedException {
    final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>();
    socket = client();
    socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() {
        @Override
        public void call(Object... objects) {
            socket.send("foo", "bar");
    }).on(Socket.EVENT_MESSAGE, new Emitter.Listener() {
        @Override
        public void call(Object... args) {
            values.offer(args);
    socket.connect();
    assertThat((Object[])values.take(), is(new Object[] {"hello client"}));
    assertThat((Object[])values.take(), is(new Object[] {"foo", "bar"}));
    socket.disconnect();
}

public static CompletionStage<String> createGreeting(CompletableFuture<String> future) {
    return future.thenApply(result -> "Hello " + result);
}

@Test
public void testDoSomething() throws Exception {
    CompletableFuture<String> innerFuture = new CompletableFuture<>();
    CompletableFuture<String> futureResult = createGreeting(innerFuture).toCompletableFuture();
    assertFalse(futureResult.isDone());
    // this triggers the future to complete
    innerFuture.complete("world");
    assertTrue(futureResult.isDone());
    // futher asserts about fooResult here
    assertEquals(futureResult.get(), "Hello world");
}

ExecutorService executorService = Executors.newSingleThreadExecutor();

public void method() {
        CompletableFuture.runAsync(() -> {
            //logic
            //logic
            //logic
            //logic
    }

public void refactoredMethod() {
    CompletableFuture.runAsync(this::subMethod);
private void subMethod() {
    //logic
    //logic

如何使用JUnit测试异步流程

13 个回答