JUnit terminates child threads

Question

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 chil

Answer 1

Perhaps group your threads with an ExecutorService, then use shutdown and awaitTermination method ?

The condition is to use Runnable or Future, not Threads themselves.

Answer 2

        while (s.isRunning()) {
            try {
                Thread.sleep(SLEEP_TIME);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

You could try to block the JUnit thread and have it wait for your thread to complete. The Thread.sleep() is needed so that your thread does not hog CPU. In this example s would be your thread you will need to have an isRunning() method so you can check if the thread is still running every SLEEP_TIME milliseconds. I know this isn't the greatest solution but if you only have 2 threads and you dont want JUnit killing your thread this works. The while loop with cause this JUnit thread to stay alive and wait for your other thread to finish.

Answer 3

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.

Answer 4

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.

Answer 5

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.

Answer 6

In java, try use CountDownLatch to make the main thread wait until the child thread completed.

    @Test
    public void myTest() {
        CountDownLatch countDownLatch = new CountDownLatch(1);
        new Thread(new Runnable() {
            @Override
            public void run() {
                //write your logic here
                countDownLatch.countDown();
            }
        }).start();
        //wait until the child thread completed.
        countDownLatch.await();
    }