Esiste un equivalente JUn all'attributo testcase di NUnit?

Question

Googled per caso di test JUnit, e si tratta con qualcosa che sembra molto più complicato da implementare - in cui è necessario creare una nuova classe che estende caso di test che poi chiama:

public class MathTest extends TestCase { 
    protected double fValue1; 
    protected double fValue2; 

    protected void setUp() { 
     fValue1= 2.0; 
     fValue2= 3.0; 
    } 
} 

public void testAdd() { 
    double result= fValue1 + fValue2; 
    assertTrue(result == 5.0); 
} 

ma quello che voglio è qualcosa di veramente semplice, come i casi di test NUnit

[TestCase(1,2)] 
[TestCase(3,4)] 
public void testAdd(int fValue1, int fValue2) 
{ 
    double result= fValue1 + fValue2; 
    assertIsTrue(result == 5.0); 
} 

esiste un modo per fare questo in JUnit?

Answer 1

È sciocco, ma ecco la soluzione che ho alla fine. Usa 4 linee invece una linea.

@Test 
public void testAdd1() { 
    testAdd(1,2); 
} 
@Test 
public void testAdd2() { 
    testAdd(3,4); 
} 
private void testAdd(int fValue1, int fValue2) 
{ 
    double result= fValue1 + fValue2; 
    assertIsTrue(result == 5.0); 
} 

Answer 2

Potrebbe anche valere la pena di verificare JUnit Theories and Datapoints. Ti permettono di parametrizzare i test, ma esegui una combinazione di tipi di tutte le coppie sui tuoi input.

Answer 3

Apparentemente la risposta corretta è "No, non esiste un equivalente". E questo è triste.

JUnit test e teorie parametrizzate (come menzionato qui e in JUnit - How to test a method with different values?) entrambi possono portare a termine il lavoro, ma in nessun posto altrettanto pulito. Sono tristemente complicati da scrivere e difficili da leggere.

Spero che un giorno JUnit possa aggiungere una sintassi più semplice, simile a NUnit. Sembra che non dovrebbe essere così difficile; anche se forse sono necessari i lambda?

Answer 4

Aggiornamento 2017: JUnit 5 include test parametrizzati tramite l'estensione junit-jupiter-params. Alcuni esempi dal documentation:

parametro standard di tipi primitivi (@ValueSource):

@ParameterizedTest 
@ValueSource(strings = { "Hello", "World" }) 
void testWithStringParameter(String argument) { 
    assertNotNull(argument); 
} 

valori separati da virgola (@CsvSource) permette di specificare parametri multipli simile a JUnitParams indicati

@ParameterizedTest 
@CsvSource({ "foo, 1", "bar, 2", "'baz, qux', 3" }) 
void testWithCsvSource(String first, int second) { 
    assertNotNull(first); 
    assertNotEquals(0, second); 
} 

Altri le annotazioni di origine includono @EnumSource, @MethodSource, @ArgumentsSource e @CsvFileSource, vedere documentation per i dettagli.

---

risposta originale:

JUnitParams (https://github.com/Pragmatists/JUnitParams) sembra una buona alternativa. Esso consente di specificare i parametri di prova come stringhe, in questo modo:

@RunWith(JUnitParamsRunner.class) 
public class MyTestSuite { 
    @Test 
    @Parameters({"1,2", "3,4"}) 
    public testAdd(int fValue1, int fValue2) { 
     ... 
    } 
} 

È inoltre possibile specificare i parametri attraverso metodi separati, classi o file, consultare il JUnitParamsRunner api docs per i dettagli.

Answer 5

Si può avere JUnit con parametri utilizzando zohhak

Esempio di utilizzo:

@RunWith(ZohhakRunner.class) 
public class HelloWorldTest { 

    @TestWith({ 
     "2, 1, 3", 
     "3, 5, 8" 
    }) 
    public void should_add_numbers(int addend1, int addend2, int result) { 

     assertThat(addend1 + addend2).isEqualTo(result); 
    } 
}