Question

So I have a method that starts five threads. I want to write a unit test just to check that the five threads have been started. How do I do that? Sample codes are much appreciated.

Answer 1

Instead of writing your own method to start threads, why not use an Executor, which can be injected into your class? Then you can easily test it by passing in a dummy Executor.

Edit: Here’s a simple example of how your code could be structured:

public class ResultCalculator {
    private final ExecutorService pool;
    private final List<Future<Integer>> pendingResults;

    public ResultCalculator(ExecutorService pool) {
        this.pool = pool;
        this.pendingResults = new ArrayList<Future<Integer>>();
    }

    public void startComputation() {
        for (int i = 0; i < 5; i++) {
            Future<Integer> future = pool.submit(new Robot(i));
            pendingResults.add(future);
        }
    }

    public int getFinalResult() throws ExecutionException {
        int total = 0;
        for (Future<Integer> robotResult : pendingResults) {
            total += robotResult.get();
        }
        return total;
    }
}

public class Robot implements Callable<Integer> {
    private final int input;

    public Robot(int input) {
        this.input = input;
    }

    @Override
    public Integer call() {
        // Some very long calculation
        Thread.sleep(10000);

        return input * input;
    }
}

And here’s how you’d call it from your main():

public static void main(String args) throws Exception {
    // Note that the number of threads is now specified here
    ExecutorService pool = Executors.newFixedThreadPool(5);
    ResultCalculator calc = new ResultCalculator(pool);
    try {
        calc.startComputation();
        // Maybe do something while we're waiting
        System.out.printf("Result is: %d\n", calc.getFinalResult());
    } finally {
        pool.shutdownNow();
    }
}

And here’s how you’d test it (assuming JUnit 4 and Mockito):

@Test
@SuppressWarnings("unchecked")
public void testStartComputationAddsRobotsToQueue() {
    ExecutorService pool = mock(ExecutorService.class);
    Future<Integer> future = mock(Future.class);
    when(pool.submit(any(Callable.class)).thenReturn(future);

    ResultCalculator calc = new ResultCalculator(pool);
    calc.startComputation();

    verify(pool, times(5)).submit(any(Callable.class));
}

Note that all this code is just a sketch which I have not tested or even tried to compile yet. But it should give you an idea of how the code can be structured.