How to handle a wait() method call in JUnit test case?

Question

I have a method that has another method call whose definition has a SomeIntegerObject.wait() call. Now when I run my test case, due to this wait method, the test case keeps waiting and doesn't execute.

I tried adding a timeout at @Test annotation but that causes an exception like "test timed out".

The test method:

private PastingResult result;
public PastingResult pasteImages(IIOImage[] images, byte pasteProcessType){
     result = new PastingResult();
     _reprocessingProvider.setListLogicHandler(this);
     //--some more method calls--
    waitForResult(); //causes my test case to wait forever and pauses execution
    return result;
}

Test case:

@Test
    public void testPasteImagesIIOImageArrayByte() throws Exception 
    {
        ReprocessManager _reprocessingProvider1=Mockito.mock(ReprocessManager.class);
        Whitebox.setInternalState(imagePasterIfImpl, "_reprocessingProvider", _reprocessingProvider1);

        IIOImage[] images=new IIOImage[]{Mockito.mock(IIOImage.class),Mockito.mock(IIOImage.class)};
        byte pasteProcessType = 02;

        PastingResult result= imagePasterIfImpl.pasteImages(images, pasteProcessType);  
        Mockito.verify(_reprocessingProvider1).setListLogicHandler(imagePasterIfImpl);
        System.out.println(result+"is the result");
    }

Definition of waitForResult();

private Integer processingWaitMonitor = new Integer(0);
private void waitForResult() {
       // synchronize to wait on the Monitor..
       synchronized(processingWaitMonitor) {
           try {
               processingWaitMonitor.wait();
           }
           catch(Exception e) {
               System.out.println("Exception during Wait !"+e);
           }
       }
   }

Answer 1

There are two answers here:

• On a first level: if you need to control something "inside" an object under test; you can either turn to Mockito Spys or PowerMock or JMockit; as those frameworks allow for "mocking" (aka gaining control) on such aspects. But that is not really good practice in most cases; if at all, you should "outsource" the required functionality into another class; and then you use dependency injection in order provide a mocked object of that class for your test setup. And instead of real waiting, you just call some wait method on a mocked object that simply does nothing.
• Beyond that: you could step back and consider to re-design your whole approach. You see, using those "low level" primitives such as wait/notify is again not good practice any more. There are abstractions such as ExecutorService, Futures, Promises. The point is: using ExecutorService, you might be able to rewrite your code to use a Same-Thread-Executor-Service for your tests. Meaning: it is possible to rewrite multi-threaded code so that just by providing a different executor for tests, all things happe on a single thread. No more waiting, guaranteed, reliable results.

Regarding your comment; your code says:

private Integer processingWaitMonitor = new Integer(0);
private void waitForResult() {

Meaning: you have a field+private method within your class under test. Assume that you create

public interface<E> WaitService {
   public E waitForResult();
}

or something like that. And then; instead of having a lock object, and that wait method inside your production class, you only keep "some" instance of that service there. But of course, that again requires you to change your production code.

If you really can't change that code (which is kind of a shame - what is the point of testing code when you can't change it ? ) ... then Mockito/PowerMock/JMockit are your only options get there.

Answer 2

The module which is going in waiting, put that in a new thread in junit test case. After intervals, check if thread is completed or not. Set a maximum timeout for intervals. After the time out happened, check for thread completion and take decision if you want to pass it or fail it.

For example:

private static final int MAX_WAIT_TIME = 20000; //total time out in milliseconds
private static final int WAIT_INTERVAL = 1000; //wait interval till MAX_WAIT_TIME

@Test
public void testPasteImagesIIOImageArrayByte() throws Exception 
{
  Thread t = new MyThread();
  t.start();    
  int totalWaitTime = 0;
  while ((!t.isCompleted()) && totalWaitTime <= MAX_WAIT_TIME) {
    try {
        totalWaitTime += WAIT_INTERVAL;
        Thread.sleep(WAIT_INTERVAL);
    } catch (java.lang.InterruptedException e) {
        //LOG OR THROW
    }
    if(!t.isCompleted()){
      if(t.hasExceptionOccurred()){
        //fail the case
      }else{
        //take your decision here, if you want to pass it or fail it
      }
    }
  }
}

class MyThead extends Thread{
  private volatile boolean isCompleted = false;
  private volatile Throwable exception = null;
  private volatile boolean hasExceptionOccured = false;

  public void run(){
    try{
        ReprocessManager _reprocessingProvider1=Mockito.mock(ReprocessManager.class);
        Whitebox.setInternalState(imagePasterIfImpl, "_reprocessingProvider", _reprocessingProvider1);

        IIOImage[] images=new IIOImage[]{Mockito.mock(IIOImage.class),Mockito.mock(IIOImage.class)};
        byte pasteProcessType = 02;

        PastingResult result= imagePasterIfImpl.pasteImages(images, pasteProcessType);  
        Mockito.verify(_reprocessingProvider1).setListLogicHandler(imagePasterIfImpl);
        System.out.println(result+"is the result");

        synchronized(this){
          isCompleted = true;
        }
    }catch(Throwable ex){
        synchronized(this){
            exception = ex;
            hasExceptionOccured = true;
        }
    }
  }

  public synchronized boolean isCompleted(){
    return isCompleted;
  }

  public synchronized boolean hasExceptionOccurred(){
    return hasExceptionOccured;
  }

  public synchronized Throwable getExceptionOccurred(){
    return exception;
  }
}