How do I unit test asynchronous methods nicely?

Another approach:

Just dont start the thread. thats all. Asume you have a SearcherService which uses your Searcher class. Then don't start the async SearcherService, instead just call searcher.search(), which blocks until search is finished.

Searcher s = new Searcher(); s.search(); // blocks and returns when finished // now somehow check the result 

Writing unit test for async never looks nice.

It's necessary that the testMyAsyncMethod() (main thread) blocks until you are ready to check the correct behaviour. This is necessary because the test case terminates at the end of the method. So there is no way around, the question is only how you block.

A straightforward approach that does not influence much the productive code is to use a while loop: asume AsyncManager is the class under test:

ArrayList resultTarget = new ArrayList(); AsyncManager fixture = new AsyncManager(resultTarget); fixture.startWork(); // now wait for result, and avoid endless waiting int numIter = 10; // correct testcase expects two events in resultTarget int expected = 2; while (numIter > 0 && resulTarget.size() < expected) { Thread.sleep(100); numIter--; } assertEquals(expected, resulTarget.size()); 

productive code would use apropriate target in the constructor of AsyncManager or uses another constructor. For test purpose we can pass our test target.

You will write this only for inherent async tasks like your own message queue. for other code, only unitest the core part of the class that performs the calculation task, (a special algorithm, etc) you dont need to let it run in a thread.

However for your search listener the shown principle with loop and wait is appropriate.

public class SearchTest extends UnitTest implements SearchListener { public void searchFinished() { this.isSearchFinished = true; } public void testSearch1() { // Todo setup your search listener, and register this class to receive Searcher searcher = new Searcher(); searcher.setListener(this); // Todo setup thread searcherThread.search(); asserTrue(checkSearchResult("myExpectedResult1")); } private boolean checkSearchResult(String expected) { boolean isOk = false; int numIter = 10; while (numIter > 0 && !this.isSearchFinished) { Thread.sleep(100); numIter--; } // todo somehow check that search was correct isOk = ..... return isOk; } } 

Create a synchronous version of the class that listens for its own results and uses an internal latch that search() waits on and searchFinished() clears. Like this:

public static class SynchronousSearcher implements SearcherListener { private CountDownLatch latch = new CountDownLatch(1); private String[] results; private class WaitingSearcher extends Searcher { @Override public void search(String input) { super.search(input); try { latch.await(); } catch (InterruptedException e) { throw new RuntimeException(e); } } } public String[] search(String input) { WaitingSearcher searcher = new WaitingSearcher(); searcher.listener = this; searcher.search(input); return results; } @Override public void searchFinished(String[] results) { this.results = results; latch.countDown(); } } 

Then to use it, simply:

String[] results = new SynchronousSearcher().search("foo"); 

There are no threads, no wait loops and the method returns in the minimal possible time. It also doesn't matter if the search returns instantly - before the call to await() - because await() will immediately return if the latch is already at zero.