unit-testing - create - unit testing visual studio 2015

¿Hay un JUnit equivalente al atributo testcase de NUnit?

Question

Busqué en Google el caso de prueba de JUnit, y se me ocurre algo que parece mucho más complicado de implementar: donde tienes que crear una nueva clase que amplíe el caso de prueba, al que luego llamas:

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 realmente simple, como los casos de prueba 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

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

Las pruebas y teorías parametrizadas de JUnit (como se menciona aquí y en JUnit - ¿Cómo probar un método con valores diferentes? ) Ambas pueden hacer el trabajo, pero en ninguna parte de forma tan limpia. Tristemente son complicadas de escribir y difíciles de leer.

Espero que algún día JUnit pueda agregar una sintaxis más simple, como NUnit. Parece que no debería ser tan difícil; aunque quizás se necesitan las lambdas?

Answer 2

Es una tontería, pero aquí está la solución que tengo al final. Utilice 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 3

Puedes tener junit con parámetros usando 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);
    }
}

Answer 4

También podría valer la pena echar un vistazo a las teorías y puntos de datos de JUnit . Le permiten parametrizar las pruebas, pero ejecutan una combinación de todos los pares en sus entradas.

Answer 5

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

Parámetro único de tipos primitivos ( @ValueSource ):

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

Los valores separados por comas ( @CsvSource ) permiten especificar múltiples parámetros similares a JUnitParams a continuación:

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

Otras anotaciones de origen incluyen @EnumSource , @MethodSource , @ArgumentsSource y @CsvFileSource , consulte la documentation para obtener más información.

Respuesta original:

JUnitParams ( https://github.com/Pragmatists/JUnitParams ) parece una alternativa decente. Te permite especificar parámetros de prueba como cadenas, como esto:

@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, clases o archivos separados, consulte la documentación de la API JUnitParamsRunner para obtener más detalles.