JUnit Testing Exceptions

Question

Sono davvero nuovo di java.

Sto eseguendo alcuni test JUnit su un costruttore. Il costruttore è tale che se viene data una stringa vuota o vuota per uno dei suoi parametri, si suppone che generi un'eccezione.

Quando provo questo costruttore in JUnit con un parametro di stringa vuoto o vuoto, ottengo una barra rossa, anche se sono quasi sicuro al 100% che il metodo di costruzione lanci effettivamente un'eccezione quando tali parametri vengono passati in ad esso.

Non dovrebbe esserci una barra verde in JUnit se il metodo genera un'eccezione come dovrebbe? O è questo quando si suppone di ottenere una barra rossa quando il lancio di eccezione funziona come dovrebbe?

Answer 1

Indica a Junit che l'eccezione è il risultato previsto, quindi il test verrà passato (contrassegnato come verde) quando viene generata un'eccezione.

Per

@Test 

Junit prenderà in considerazione test come non riuscito se viene lanciata un'eccezione.
Questo link potrebbe aiutare.

Answer 2

sei sicuro di aver detto di aspettarsi l'eccezione?

per più recente JUnit (> = 4.7), è possibile usare qualcosa di simile (da here)

@Rule 
public ExpectedException exception = ExpectedException.none(); 

@Test 
public void testRodneCisloRok(){ 
    exception.expect(IllegalArgumentException.class); 
    exception.expectMessage("error1"); 
    new RodneCislo("891415",dopocitej("891415")); 
} 

e per JUnit anziani, questo:

@Test(expected = ArithmeticException.class) 
public void divisionWithException() { 
    int i = 1/0; 
} 

Answer 3

Se il costruttore è simile a questo uno:

public Example(String example) { 
    if (example == null) { 
     throw new NullPointerException(); 
    } 
    //do fun things with valid example here 
} 

Poi, quando si esegue questo test JUnit avrete una barra verde:

Answer 4

Un adventage di utilizzo ExpectedException Rule (versione 4.7) è che è possibile verificare il messaggio di eccezione e non solo l'eccezione prevista.

E usando Matchers, è possibile verificare la parte del messaggio che vi interessa:

exception.expectMessage(containsString("income: -1000.0")); 

Answer 5

Anche se @Test(expected = MyException.class) e la ExpectedException rule sono molto buone scelte, ci sono alcuni casi in cui l'eccezione in stile JUnit3 cattura è ancora il migliore strada da percorrere:

@Test public void yourTest() { 
    try { 
    systemUnderTest.doStuff(); 
    fail("MyException expected."); 
    } catch (MyException expected) { 

    // Though the ExpectedException rule lets you write matchers about 
    // exceptions, it is sometimes useful to inspect the object directly. 

    assertEquals(1301, expected.getMyErrorCode()); 
    } 

    // In both @Test(expected=...) and ExpectedException code, the 
    // exception-throwing line will be the last executed line, because Java will 
    // still traverse the call stack until it reaches a try block--which will be 
    // inside the JUnit framework in those cases. The only way to prevent this 
    // behavior is to use your own try block. 

    // This is especially useful to test the state of the system after the 
    // exception is caught. 

    assertTrue(systemUnderTest.isInErrorState()); 
} 

Un'altra libreria che pretende di aiutare qui è catch-exception; tuttavia, a partire da maggio 2014, il progetto sembra essere in modalità di manutenzione (obsoleto da Java 8), e molto simile all'eccezione catch di Mockito può solo manipolare metodi non final.