¿Hay un JUnit equivalente al atributo testcase de NUnit?

Question

He buscado en Google para el caso de prueba unitaria, y viene con algo que se parece mucho más complicado de implementar - donde usted tiene que crear una nueva clase que se extiende caso de prueba que luego se llama:

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); 
} 

pero lo que quiero es algo muy simple, como los casos de prueba de NUnit

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

¿hay alguna manera de hacer esto en JUnit?

Answer 1

Es tonto pero aquí está la solución que tengo al final. Use 4 líneas en lugar de una línea.

@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

También podría ser útil para comprobar JUnit Theories and Datapoints. Le permiten parametrizar las pruebas, pero ejecuta una combinación de tipos de todos los pares en sus entradas.

Answer 3

Aparentemente, la respuesta correcta es "No, no hay equivalente". Y eso es triste.

JUnit pruebas y teorías parametrizadas (como se menciona aquí y en JUnit - How to test a method with different values?) ambas pueden hacer el trabajo, pero en ninguna parte tan limpiamente. Son tristemente complicados de escribir y difíciles de leer.

Espero que algún día JUnit pueda agregar una sintaxis similar a NUnit. Parece que no debería ser tan difícil; aunque tal vez se necesitan lambdas?

Answer 4

actualización 2017: JUnit 5 incluirá pruebas parametrizadas a través de la extensión junit-jupiter-params. Algunos ejemplos de la documentation:

parámetro individual de tipos primitivos (@ValueSource):

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

valores separados por comas (@CsvSource) permite especificar múltiples parámetros similares a JUnitParams siguientes:

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

Otros las anotaciones de origen incluyen @EnumSource, @MethodSource, @ArgumentsSource y @CsvFileSource, consulte el documentation para más detalles.

---

Respuesta original:

JUnitParams (https://github.com/Pragmatists/JUnitParams) parece una alternativa decente. Se le permite especificar los parámetros de prueba como cadenas, así:

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

También puede especificar parámetros a través de métodos distintos, clases o archivos, consultar el JUnitParamsRunner api docs para más detalles.

Answer 5

Puede tener JUnit con parámetros utilizando zohhak

Ejemplo de uso:

@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); 
    } 
}