JUnit Exception Testing

Question

Modifica: non disponibile JUnit 4 in questo momento.

Hi there,

Ho una domanda sui test "intelligente" eccezione con JUnit. In questo momento, lo faccio in questo modo:

public void testGet() { 

    SoundFileManager sfm = new SoundFileManager(); 

     // Test adding a sound file and then getting it by id and name. 
     try { 
      SoundFile addedFile = sfm.addSoundfile("E:\\Eclipse_Prj\\pSound\\data\\Adrenaline01.wav"); 
      SoundFile sf = sfm.getSoundfile(addedFile.getID()); 
      assertTrue(sf!=null); 
      System.out.println(sf.toString()); 

      sf = sfm.getSoundfileByName("E:\\Eclipse_Prj\\pSound\\data\\Adrenaline01.wav"); 
      assertTrue(sf!=null); 
      System.out.println(sf.toString()); 
     } catch (RapsManagerException e) { 
      System.out.println(e.getMessage()); 
     } 

     // Test get with invalid id. 
     try { 
      sfm.getSoundfile(-100); 
      fail("Should have raised a RapsManagerException"); 
     } catch (RapsManagerException e) { 
      System.out.println(e.getMessage()); 
     } 

     // Test get by name with invalid name 
     try { 
      sfm.getSoundfileByName(new String()); 
      fail("Should have raised a RapsManagerException"); 
     } catch (RapsManagerException e) { 
      System.out.println(e.getMessage()); 
     } 

    } 

Come potete vedere, ho bisogno di un blocco try/catch per ogni funzione che dovrebbe generare un'eccezione. Sembra non essere un buon modo per farlo - o non c'è possibilità di ridurre l'uso di try/catch?

Answer 1

Suggerisco che è necessario suddividere lo testGet in più test separati. I singoli blocchi try/catch sembrano essere piuttosto indipendenti l'uno dall'altro. Si consiglia inoltre di estrarre la logica di inizializzazione comune nel proprio metodo di installazione.

Una volta che avete, è possibile utilizzare il supporto eccezione annotazioni di JUnit4, qualcosa di simile:

public class MyTest { 

private SoundManager sfm; 

@Before 
public void setup() { 
     sfm = new SoundFileManager(); 
} 

@Test 
public void getByIdAndName() { 
    // Test adding a sound file and then getting it by id and name. 
     SoundFile addedFile =    
     sfm.addSoundfile("E:\\Eclipse_Prj\\pSound\\data\\Adrenaline01.wav"); 
     SoundFile sf = sfm.getSoundfile(addedFile.getID()); 
     assertTrue(sf!=null); 
     System.out.println(sf.toString()); 

     sf = sfm.getSoundfileByName("E:\\Eclipse_Prj\\pSound\\data\\Adrenaline01.wav"); 
     assertTrue(sf!=null); 
     System.out.println(sf.toString()); 
} 

@Test(expected=RapsManagerException.class) 
public void getByInvalidId() { 
     // Test get with invalid id. 
     sfm.getSoundfile(-100); 
} 

@Test(expected=RapsManagerException.class) 
public void getByInvalidName() { 
     // Test get with invalid id. 
     sfm.getSoundfileByName(new String()); 
} 
} 

Answer 2

Con JUnit 4, è possibile utilizzare invece le annotazioni. Tuttavia, è necessario separare il test in 3 metodi distinti affinché questo funzioni in modo pulito. Si noti che IMHO che rileva un'eccezione nel primo scenario dovrebbe essere un errore, pertanto ho modificato il blocco catch di conseguenza.

public void testGet() { 
    SoundFileManager sfm = new SoundFileManager(); 

    // Test adding a sound file and then getting it by id and name. 
    try { 
     SoundFile addedFile = sfm.addSoundfile("E:\\Eclipse_Prj\\pSound\\data\\Adrenaline01.wav"); 
     SoundFile sf = sfm.getSoundfile(addedFile.getID()); 
     assertTrue(sf!=null); 
     System.out.println(sf.toString()); 

     sf = sfm.getSoundfileByName("E:\\Eclipse_Prj\\pSound\\data\\Adrenaline01.wav"); 
     assertTrue(sf!=null); 
     System.out.println(sf.toString()); 
    } catch (RapsManagerException e) { 
     fail(e.getMessage()); 
    } 
} 

@Test(expected=RapsManagerException.class) 
public void testGetWithInvalidId() { 
    SoundFileManager sfm = new SoundFileManager(); 

    sfm.getSoundfile(-100); 
} 

@Test(expected=RapsManagerException.class) 
public void testGetWithInvalidName() { 
    SoundFileManager sfm = new SoundFileManager(); 

    sfm.getSoundfileByName(new String()); 
} 

Answer 3

Se si dispone di un'eccezione prevista e non è possibile utilizzare un'annotazione per intrappolare esso, è necessario prenderlo e affermare che hai quello che ti aspettavi. Ad esempio:

Throwable caught = null; 
try { 
    somethingThatThrows(); 
} catch (Throwable t) { 
    caught = t; 
} 
assertNotNull(caught); 
assertSame(FooException.class, caught.getClass()); 

Se è possibile utilizzare un'annotazione, farlo è molto più chiaro. Ma questo non è sempre possibile (ad esempio perché stai testando una sequenza di metodi o perché stai utilizzando JUnit 3).

Answer 4

La sintassi più concisa è fornita da catch-exception:

public void testGet() { 
    SoundFileManager sfm = new SoundFileManager(); 
    ... // setup sound file manager 

    verifyException(sfm, RapsManagerException.class) 
     .getSoundfile(-100); 

    verifyException(sfm, RapsManagerException.class) 
     .getSoundfileByName(new String()); 
} 

Answer 5

In Java 8, è possibile usa le espressioni lambda per ottenere un controllo più stretto su quando viene lanciata l'eccezione. Se si utilizza il metodo delle annotazioni, si asserisce solo che l'eccezione è generata da qualche parte nel metodo di prova. Se stai eseguendo più di una riga di codice nel test, rischi di passare il test quando dovrebbe fallire. La soluzione Java 8 è qualcosa di simile.

static void <T extends Exception> expectException(Class<T> type, Runnable runnable) { 
    try { 
     runnable.run() 
    } catch (Exception ex) { 
     assertTrue(ex.getClass().equals(type)); 
     return; 
    } 
    assertTrue(false); 
} 

Usage:

@Test 
public void test() 
    MyClass foo = new MyClass(); 
    // other setup code here .... 
    expectException(MyException.class,() -> foo.bar()); 
}