Java Thread.currentThread(). SetUncaughtExceptionHandler() non funziona con JUNIT?

Question

Nel codice di esempio seguente, se il testMethod() viene eseguito tramite main() funziona come previsto ma se viene eseguito tramite JUNIT, MyUncaughtExceptionHandler non viene richiamato.

C'è qualche spiegazione per questo?

package nz.co.test; 

import java.lang.Thread.UncaughtExceptionHandler; 

import org.junit.Test; 

public class ThreadDemo { 

    private void testMethod() { 
    Thread.currentThread().setUncaughtExceptionHandler(new MyUncaughtExceptionHandler()); 

    Object b = null; 
    // Cause a NPE 
    b.hashCode(); 
    } 

    @Test 
    public void testJunit() { 
    // Run via JUnit and MyUncaughtExceptionHandler doesn't catch the Exception 
    testMethod(); 
    } 

    public static void main(String[] args) { 
    // Run via main() works as expected 
    new ThreadDemo().testMethod(); 
    } 

    static class MyUncaughtExceptionHandler implements UncaughtExceptionHandler { 

    @Override 
    public void uncaughtException(Thread t, Throwable e) { 
     System.out.println("I caught the exception"); 
    } 
    } 
} 

Answer 1

Questo perché tutte eccezione che vengono gettati in un test vengono catturati ed elaborati da JUnit, così UncaughtExceptionHandler non ottiene tutte le eccezioni non gestite fanno. E 'fatto in org.junit.runners.ParentRunners

... 
    protected final void runLeaf(Statement statement, Description description, 
      RunNotifier notifier) { 
     EachTestNotifier eachNotifier = new EachTestNotifier(notifier, description); 
     eachNotifier.fireTestStarted(); 
     try { 
      statement.evaluate(); <-- test method execution is called from here 
     } catch (AssumptionViolatedException e) { 
      eachNotifier.addFailedAssumption(e); 
     } catch (Throwable e) { 
      eachNotifier.addFailure(e); 
     } finally { 
      eachNotifier.fireTestFinished(); 
     } 
    } 

Answer 2

Ovviamente, il gestore setUncaughtExceptionHandler set per le eccezioni non gestite fanno. Ma JUnit recupera tutte le eccezioni generate dai metodi di prova.

In ogni caso, è un modo strano di fare un test unitario. Il test unitario dovrebbe testare il codice, non la specifica JVM.

immagino uno unit test come questo:

public class MyUncaughtExceptionHandlerTest 
{ 
    @Mock Thread thread; 
    MyUncaughtExceptionHandler testObject = new MyUncaughtExceptionHandler(); 

    @Before 
    public void setUp() 
    { 
    MockitoAnnotations.initMocks(this); 
    } 

    @Test 
    public void handleNpeShouldDoOneThing() 
    { 
    testObject.handleException(thread, new NullPointerException()); 
    //verify(oneThing) 
    } 

    @Test 
    public void handleOomShouldDoSomethingElse() 
    { 
    testObject.handleException(thread, new OutOfMemoryError()); 
    //verify(somethingElse) 
    } 
}