blocks|key|1393117|text|您可以尝试使用Awaitility库。它使得测试您正在谈论的系统变得很容易。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1393118|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/awaitility/awaitility^0|7|A|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

You can try using the <a href="https://github.com/awaitility/awaitility" rel="noreferrer">Awaitility</a> library. It makes it easy to test the systems you're talking about.

blocks|key|1393255|text|如果使用CompletableFuture+(在Java8中引入)或SettableFuture+(来自Google+Guava)，则可以在测试完成时立即完成测试，而不是等待预先设置的时间。您的测试将如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1393256|CompletableFuture<String>+future+=+new+CompletableFuture<>();
executorService.submit(new+Runnable()+{+++++++++
++++@Override
++++public+void+run()+{
++++++++future.complete("Hello+World!");++++++++++++++++
++++}
});
assertEquals("Hello+World!",+future.get());|code-block|syntax|javascript|1393257|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletableFuture.html|1|https://google.github.io/guava/releases/snapshot/api/docs/com/google/common/util/concurrent/SettableFuture.html|2|https://code.google.com/p/guava-libraries/^0|4|H|0|Y|E|1|1G|C|2|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]|$A|Y|B|Z|1|10]|$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]|Q|$5|L|M|N|C|$O|R]]|S|$5|L|M|N|C|$O|T]]]]

If you use a <a href="http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletableFuture.html" rel="noreferrer">CompletableFuture</a> (introduced in Java 8) or a <a href="https://google.github.io/guava/releases/snapshot/api/docs/com/google/common/util/concurrent/SettableFuture.html" rel="noreferrer">SettableFuture</a> (from <a href="https://code.google.com/p/guava-libraries/" rel="noreferrer">Google Guava</a>), you can make your test finish as soon as it's done, rather than waiting a pre-set amount of time. Your test would look something like this:

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

blocks|key|1393061|text|启动该进程，并使用Future等待结果。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1393062|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/javase/6/docs/api/java/util/concurrent/Future.html^0|9|6|9|6|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

Start the process off and wait for the result using a <a href="http://java.sun.com/javase/6/docs/api/java/util/concurrent/Future.html" rel="noreferrer"><code>Future</code></a>.

blocks|key|1608125|text|我发现测试异步方法非常有用的一种方法是在object-to-test的构造函数中注入一个Executor实例。在生产环境中，executor实例被配置为异步运行，而在测试中，它可以被模拟为同步运行。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1608126|假设我正在尝试测试异步方法Foo#doAsync(Callback+c)，|1608127|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);
++++++}
++++});
++}
}|code-block|syntax|javascript|1608128|在生产环境中，我将使用Executors.newSingleThreadExecutor()+Executor实例构建Foo，而在测试中，我可能会使用执行以下操作的同步executor来构建它--|1608129|class+SynchronousExecutor+implements+Executor+{
++@Override+public+void+execute(Runnable+r)+{
++++r.run();
++}
}|1608130|现在我的异步方法的JUnit测试已经非常清晰了--|1608131|@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());
}|1608132|entityMap^0|18|8|0|D|N|0|0|B|Z|1N|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|18|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|19|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|1A|8|@]|D|@]|E|$K|L]]|$1|U|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|V|$]]

One method I've found pretty useful for testing asynchronous methods is injecting an <code>Executor</code> instance in the object-to-test's constructor. In production, the executor instance is configured to run asynchronously while in test it can be mocked to run synchronously.

So suppose I'm trying to test the asynchronous method <code>Foo#doAsync(Callback c)</code>, 

<pre><code>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);
 }
 });
 }
}
</code></pre>

In production, I would construct <code>Foo</code> with an <code>Executors.newSingleThreadExecutor()</code> Executor instance while in test I would probably construct it with a synchronous executor that does the following --

<pre><code>class SynchronousExecutor implements Executor {
 @Override public void execute(Runnable r) {
 r.run();
 }
}
</code></pre>

Now my JUnit test of the asynchronous method is pretty clean --

<pre><code>@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());
}
</code></pre>

blocks|key|1608500|text|我找到了一个库socket.io来测试异步逻辑。使用LinkedBlockingQueue看起来简单明了。这是example|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1608501|++++@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();
}|code-block|syntax|javascript|1608502|使用LinkedBlockingQueue+take接口阻塞，直到得到结果，就像同步方式一样。并设置超时，以避免假设等待结果的时间过长。|1608503|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/socketio/socket.io-client-java|1|https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/LinkedBlockingQueue.html|2|https://github.com/socketio/socket.io-client-java/blob/master/src/test/java/io/socket/client/ServerConnectionTest.java^0|7|9|0|Q|J|1|1J|7|2|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]|$A|10|B|11|1|12]|$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]|U|$5|N|O|P|C|$Q|V]]]]

I find an library <a href="https://github.com/socketio/socket.io-client-java" rel="nofollow noreferrer">socket.io</a> to test asynchronous logic. It looks simple and brief way using <a href="https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/LinkedBlockingQueue.html" rel="nofollow noreferrer">LinkedBlockingQueue</a>. Here is <a href="https://github.com/socketio/socket.io-client-java/blob/master/src/test/java/io/socket/client/ServerConnectionTest.java" rel="nofollow noreferrer">example</a>:

<pre><code> @Test(timeout = TIMEOUT)
public void message() throws URISyntaxException, InterruptedException {
 final BlockingQueue&lt;Object&gt; values = new LinkedBlockingQueue&lt;Object&gt;();

 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();
}
</code></pre>

Using LinkedBlockingQueue take API to block until to get result just like synchronous way. And set timeout to avoid assuming too much time to wait the result.

blocks|key|1608549|text|值得一提的是，Concurrency+in+Practice中有一个非常有用的章节Testing+Concurrent+Programs，它描述了一些单元测试方法，并给出了问题的解决方案。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1608550|entityMap|0|LINK|mutability|MUTABLE|url|https://rads.stackoverflow.com/amzn/click/com/B004V9OA84^0|15|R|7|N|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

It's worth mentioning that there is very useful chapter <code>Testing Concurrent Programs</code> in <a href="https://rads.stackoverflow.com/amzn/click/com/B004V9OA84" rel="nofollow noreferrer" rel="nofollow noreferrer">Concurrency in Practice</a> which describes some unit testing approaches and gives solutions for issues.

blocks|key|1608414|text|如果测试结果是异步产生的，这就是我现在使用的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1608415|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+%7C+TimeoutException+e)+{
++++++++++++throw+new+RuntimeException("Future+timed+out",+e);
++++++++}+catch+(ExecutionException+e)+{
++++++++++++throw+new+RuntimeException("Future+failed",+e.getCause());
++++++++}
++++}
}|code-block|syntax|javascript|1608416|使用静态导入，测试读起来不错。(注意，在这个例子中，我启动了一个线程来说明这个想法)|1608417|++++@Test
++++public+void+testAsync()+{
++++++++String+result+=+await(f+->+{
++++++++++++new+Thread(()+->+f.complete("My+Result")).start();
++++++++});
++++++++assertEquals("My+Result",+result);
++++}|1608418|如果没有调用f.complete，测试将在超时后失败。您还可以使用f.completeExceptionally提早失败。|offset|length|style|CODE|1608419|entityMap^0|0|0|0|0|6|A|X|N|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]|$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

This is what I'm using nowadays if the test result is produced asynchronously.

<pre><code>public class TestUtil {

 public static &lt;R&gt; R await(Consumer&lt;CompletableFuture&lt;R&gt;&gt; completer) {
 return await(20, TimeUnit.SECONDS, completer);
 }

 public static &lt;R&gt; R await(int time, TimeUnit unit, Consumer&lt;CompletableFuture&lt;R&gt;&gt; completer) {
 CompletableFuture&lt;R&gt; f = new CompletableFuture&lt;&gt;();
 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());
 }
 }
}
</code></pre>

Using static imports, the test reads kinda nice.
(note, in this example I'm starting a thread to illustrate the idea)

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

If <code>f.complete</code> isn't called, the test will fail after a timeout. You can also use <code>f.completeExceptionally</code> to fail early.

blocks|key|1393523|text|这里有很多答案，但一个简单的方法就是创建一个完整的CompletableFuture并使用它：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1393524|CompletableFuture.completedFuture("donzo")|code-block|syntax|javascript|1393525|所以在我的测试中：|1393526|this.exactly(2).of(mockEventHubClientWrapper).sendASync(with(any(LinkedList.class)));
this.will(returnValue(new+CompletableFuture<>().completedFuture("donzo")));|1393527|我只是想确保所有这些东西都会被调用。如果您使用以下代码，则此技术有效：|1393528|CompletableFuture.allOf(calls.toArray(new+CompletableFuture[0])).join();|1393529|它将快速通过它，因为所有的CompletableFutures都完成了！|1393530|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

There are many answers here but a simple one is to just create a completed CompletableFuture and use it:

<pre><code>CompletableFuture.completedFuture("donzo")
</code></pre>

So in my test:

<pre><code>this.exactly(2).of(mockEventHubClientWrapper).sendASync(with(any(LinkedList.class)));
this.will(returnValue(new CompletableFuture&lt;&gt;().completedFuture("donzo")));
</code></pre>

I am just making sure all of this stuff gets called anyway. This technique works if you are using this code:

<pre><code>CompletableFuture.allOf(calls.toArray(new CompletableFuture[0])).join();
</code></pre>

It will zip right through it as all the CompletableFutures are finished!

blocks|key|1608606|text|尽可能避免使用并行线程进行测试(大多数时候是这样)。这只会使您的测试变得不稳定(有时通过，有时失败)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1608607|只有当您需要调用其他库/系统时，才可能需要等待其他线程，在这种情况下，请始终使用Awaitility库而不是Thread.sleep()。|offset|length|style|CODE|1608608|永远不要在测试中调用get()或join()，否则您的测试可能会永远在CI服务器上运行，以防将来永远不会完成。在调用get()之前，请始终在测试中首先断言isDone()。对于CompletionStage来说，这就是.toCompletableFuture().isDone()。|1608609|当您测试像这样的非阻塞方法时：|1608610|public+static+CompletionStage<String>+createGreeting(CompletableFuture<String>+future)+{
++++return+future.thenApply(result+->+"Hello+"+%2B+result);
}|code-block|syntax|javascript|1608611|那么你不应该仅仅通过在测试中传递一个完整的Future来测试结果，你还应该通过调用join()或get()来确保你的方法doSomething()不会阻塞。如果您使用非阻塞框架，这一点尤其重要。|1608612|为此，请使用您设置为手动完成的未完成将来进行测试：|1608613|@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");
}|1608614|这样，如果将future.join()添加到doSomething()中，测试将失败。|1608615|如果您的服务使用ExecutorService，比如在thenApplyAsync(...,+executorService)中，那么在您的测试中注入一个单线程的ExecutorService，比如来自芭乐的那个：|1608616|ExecutorService+executorService+=+Executors.newSingleThreadExecutor();|1608617|如果您的代码使用thenApplyAsync(...)等forkJoinPool，请重写代码以使用ExecutorService+(有很多好的理由)，或者使用Awaitility。|1608618|为了缩短示例，我在测试中将BarService设置为一个实现为Java8λ的方法参数，通常它是一个注入引用，您可以模拟它。|1608619|entityMap|0|LINK|mutability|MUTABLE|url|http://code.google.com/p/awaitility/^0|0|1I|E|14|A|0|0|A|5|G|6|1M|5|25|8|31|V|0|0|0|15|6|1C|5|1O|D|0|0|0|6|D|0|R|10|0|0|8|J|0|0^^$0|@$1|2|3|4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1F|8|@$D|1G|E|1H|F|G]]|9|@$D|1I|E|1J|1|1K]]|A|$]]|$1|H|3|I|5|6|7|1L|8|@$D|1M|E|1N|F|G]|$D|1O|E|1P|F|G]|$D|1Q|E|1R|F|G]|$D|1S|E|1T|F|G]|$D|1U|E|1V|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1W|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|1X|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|1Y|8|@$D|1Z|E|20|F|G]|$D|21|E|22|F|G]|$D|23|E|24|F|G]]|9|@]|A|$]]|$1|S|3|T|5|6|7|25|8|@]|9|@]|A|$]]|$1|U|3|V|5|N|7|26|8|@]|9|@]|A|$O|P]]|$1|W|3|X|5|6|7|27|8|@$D|28|E|29|F|G]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|2A|8|@$D|2B|E|2C|F|G]]|9|@]|A|$]]|$1|10|3|11|5|N|7|2D|8|@]|9|@]|A|$O|P]]|$1|12|3|13|5|6|7|2E|8|@$D|2F|E|2G|F|G]]|9|@]|A|$]]|$1|14|3|15|5|6|7|2H|8|@]|9|@]|A|$]]|$1|16|3|-4|5|6|7|2I|8|@]|9|@]|A|$]]]|17|$18|$5|19|1A|1B|A|$1C|1D]]]]

Avoid testing with parallel threads whenever you can (which is most of the time). This will only make your tests flaky (sometimes pass, sometimes fail).

Only when you need to call some other library / system, you might have to wait on other threads, in that case always use the <a href="http://code.google.com/p/awaitility/" rel="nofollow noreferrer">Awaitility</a> library instead of <code>Thread.sleep()</code>.

Never just call <code>get()</code> or <code>join()</code> in your tests, else your tests might run forever on your CI server in case the future never completes. Always assert <code>isDone()</code> first in your tests before calling <code>get()</code>. For CompletionStage, that is <code>.toCompletableFuture().isDone()</code>.

When you test a non-blocking method like this:

<pre><code>public static CompletionStage&lt;String&gt; createGreeting(CompletableFuture&lt;String&gt; future) {
 return future.thenApply(result -&gt; "Hello " + result);
}
</code></pre>

then you should not just test the result by passing a completed Future in the test, you should also make sure that your method <code>doSomething()</code> does not block by calling <code>join()</code> or <code>get()</code>. This is important in particular if you use a non-blocking framework.

To do that, test with a non-completed future that you set to completed manually:

<pre><code>@Test
public void testDoSomething() throws Exception {
 CompletableFuture&lt;String&gt; innerFuture = new CompletableFuture&lt;&gt;();
 CompletableFuture&lt;String&gt; 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");
}
</code></pre>

That way, if you add <code>future.join()</code> to doSomething(), the test will fail.

If your Service uses an ExecutorService such as in <code>thenApplyAsync(..., executorService)</code>, then in your tests inject a single-threaded ExecutorService, such as the one from guava:

<pre><code>ExecutorService executorService = Executors.newSingleThreadExecutor();
</code></pre>

If your code uses the forkJoinPool such as <code>thenApplyAsync(...)</code>, rewrite the code to use an ExecutorService (there are many good reasons), or use Awaitility.

To shorten the example, I made BarService a method argument implemented as a Java8 lambda in the test, typically it would be an injected reference that you would mock.

blocks|key|1608739|text|Mockito+5有Assertions.assertTimeout(Duration,+Executable)/assertTimeoutPreemptively()(请阅读各自的Javadoc以了解其中的区别)，而JUnit有verify(mock,+timeout(millisecs).times(x))。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1608740|Assertions.assertTimeout(Duration.ofMillis(1000),+()+->+
++++myReactiveService.doSth().subscribe()
);|code-block|syntax|javascript|1608741|和：|1608742|Mockito.verify(myReactiveService,+
++++timeout(1000).times(0)).doSth();+//+cannot+use+never()+here|1608743|在管道中，超时可能是不确定的/脆弱的。所以要小心。|1608744|entityMap^0|A|1A|1L|R|37|15|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|12|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|R|$]]

JUnit 5 has <code>Assertions.assertTimeout(Duration, Executable)</code>/<code>assertTimeoutPreemptively()</code>(please read Javadoc of each to understand the difference) and Mockito has <code>verify(mock, timeout(millisecs).times(x))</code>.
<pre><code>Assertions.assertTimeout(Duration.ofMillis(1000), () -&gt; 
 myReactiveService.doSth().subscribe()
);
</code></pre>
And:
<pre><code>Mockito.verify(myReactiveService, 
 timeout(1000).times(0)).doSth(); // cannot use never() here
</code></pre>
Timeout may be nondeterministic/fragile in pipelines. So be careful.

blocks|key|1608272|text|我更喜欢使用等待和通知。它简单明了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1608273|@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];
++++}
}|code-block|syntax|javascript|1608274|基本上，我们需要创建一个最终的数组引用，在匿名内部类中使用。我更愿意创建一个boolean[]，因为我可以设置一个值来控制我们是否需要等待()。当一切都完成后，我们只需要释放asyncExecuted。|1608275|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I prefer use wait and notify. It is simple and clear.

<pre><code>@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];
 }
}
</code></pre>

Basically, we need to create a final Array reference, to be used inside of anonymous inner class. I would rather create a boolean[], because I can put a value to control if we need to wait(). When everything is done, we just release the asyncExecuted.

blocks|key|1608340|text|如果你想测试逻辑，就不要异步测试它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1608341|例如，为了测试这段代码，它处理异步方法的结果。|1608342|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+++++++
++++}
}|code-block|syntax|javascript|1608343|在测试中，使用同步实现模拟依赖关系。单元测试是完全同步的，运行时间为150ms。|1608344|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")));
++++}
}|1608345|您不测试异步行为，但您可以测试逻辑是否正确。|1608346|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

If you want to test the logic just don´t test it asynchronously.

For example to test this code which works on results of an asynchronous method.

<pre><code>public class Example {
 private Dependency dependency;

 public Example(Dependency dependency) {
 this.dependency = dependency; 
 }

 public CompletableFuture&lt;String&gt; someAsyncMethod(){
 return dependency.asyncMethod()
 .handle((r,ex) -&gt; {
 if(ex != null) {
 return "got exception";
 } else {
 return r.toString();
 }
 });
 }
}

public class Dependency {
 public CompletableFuture&lt;Integer&gt; asyncMethod() {
 // do some async stuff 
 }
}
</code></pre>

In the test mock the dependency with synchronous implementation. The unit test is completely synchronous and runs in 150ms.

<pre><code>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&lt;String&gt; 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&lt;Integer&gt; c = new CompletableFuture&lt;Integer&gt;();
 c.completeExceptionally(new RuntimeException("failed"));
 when(dependency.asyncMethod()).thenReturn(c);

 // When
 CompletableFuture&lt;String&gt; result = sut.someAsyncMethod();

 // Then
 assertThat(result.isCompletedExceptionally(), is(equalTo(false)));
 String value = result.get();
 assertThat(value, is(equalTo("got exception")));
 }
}
</code></pre>

You don´t test the async behaviour but you can test if the logic is correct.

blocks|key|1608687|text|假设你有这样的代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1608688|public+void+method()+{
++++++++CompletableFuture.runAsync(()+->+{
++++++++++++//logic
++++++++++++//logic
++++++++++++//logic
++++++++++++//logic
++++++++});
++++}|code-block|syntax|javascript|1608689|尝试将其重构为如下所示：|1608690|public+void+refactoredMethod()+{
++++CompletableFuture.runAsync(this::subMethod);
}

private+void+subMethod()+{
++++//logic
++++//logic
++++//logic
++++//logic
}|1608691|在此之后，按如下方式测试subMethod：|1608692|org.powermock.reflect.Whitebox.invokeMethod(classInstance,+"subMethod");+|1608693|这不是一个完美的解决方案，但它测试了异步执行中的所有逻辑。|1608694|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Let's say you have this code:
<pre><code>public void method() {
 CompletableFuture.runAsync(() -&gt; {
 //logic
 //logic
 //logic
 //logic
 });
 }
</code></pre>
Try to refactor it to something like this:
<pre><code>public void refactoredMethod() {
 CompletableFuture.runAsync(this::subMethod);
}

private void subMethod() {
 //logic
 //logic
 //logic
 //logic
}
</code></pre>
After that, test the subMethod this way:
<pre><code>org.powermock.reflect.Whitebox.invokeMethod(classInstance, &quot;subMethod&quot;); 
</code></pre>
This isn't a perfect solution, but it tests all the logic inside your async execution.

How do you test methods that fire asynchronous processes with JUnit?

I don't know how to make my test wait for the process to end (it is not exactly a unit test, it is more like an integration test as it involves several classes and not just one).

How to use JUnit to test asynchronous processes

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云AI代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

如何使用JUnit测试触发异步流程的方法？我不知道如何让我的测试等待过程结束(它不完全是单元测试，它更像是集成测试，因为它涉及多个类，而不只是一个类)。

问如何使用JUnit测试异步流程
EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何使用JUnit测试异步流程EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何使用JUnit测试异步流程
EN