JUnit terminates child threads

When I test the execution of a method that creates a child thread, the JUnit test ends before the child thread and kills it.

How do I force JUnit to wait for the child thread to complete its execution?

After reading the question and some comments, it seems that what you need is a technique for unit testing asynchronous operations. doSomething() returns immediately, but you want the test code to wait for its completion, and then do some validations.

The problem is that the test is not aware of the threads being spawned by the call, so apparently it has no means of waiting for them. One can think of many sophisticated (and probably flawed) ways to solve this, but in my opinion there is a design problem here. A unit test should simulate a client of some API, and it should not assume anything about the implementation; It should only test functionality, as reflected by the API and its documentation. Therefore, I would avoid trying to detect and track the threads created by the async call. Instead, I would improve the API of the tested class, if needed. The class where the async call belongs to should provide some mechanism for detecting termination. I can think of 3 ways, but there are probably more:

1. Allow registering a listener that gets notified once the operation is completed

2. Providing a synchronous version of the operation. The implementation can call the async version, and then block until completion. If the class should not be exposing such a method, its visibility can be reduced to package protected, so that the test can access it.

3. Using the wait-notify pattern, on some visible object.

If the class provides no such mechanism, then it is not really testable, and worse, it is probably not very reusable either.

Try using thread.join() on the created thread. This will wait for that thread to die.

Edit: to avoid this, try Thread.getThreadGroup().setDaemon(true); in the test, or perhaps in the setUp() method. I haven't tested this though.

A daemon thread group is automatically destroyed when its last thread is stopped or its last thread group is destroyed.

I wonder if JUnit is calling System.exit() or something as soon as the test finishes, however.

The basic technique that @Eyal outlined is what ConcurrentUnit is intended for. The general usage is:

1. Spawn some threads
2. Have the main thread wait or sleep
3. Perform assertions from within the worker threads (which via ConcurrentUnit, are reported back to the main thread)
4. Resume the main thread from one of the worker threads once all assertions are complete

See the ConcurrentUnit page for more info.