unit - run test in android studio

Android JUnit Testing... Cómo esperar una excepción

Question

Estoy intentando escribir algunas pruebas usando el marco de prueba de Junit android incorporado. Me encuentro con un problema con una prueba en la que espero que se emita una excepción. En JUnit, la anotación para el método de prueba sería:

@Test(expected = ArithmeticException.class)

Sin embargo, en Android, esta prueba falla con una ArithmeticException.

Entiendo que la implementación de Android es solo un subconjunto de JUnit 3, y que ni siquiera permite la anotación @Test (debe ser @SmallTest, @MediumTest o @LargeTest, y ninguna de ellas permite el ''expected = ..'' parámetro), pero esto parece una prueba bastante significativa, y parece que el marco de prueba de Android sería muy insuficiente si no tuviera esta característica.

Nota: Probé esto agregando el jar JUnit al proyecto y agregando y las anotaciones a mis métodos de prueba. Tiene sentido para mí por qué las anotaciones se ignorarían por completo porque el marco de Android (¿corredor?) No está buscando esa anotación y simplemente la ignora. Básicamente, solo estoy buscando la forma "correcta" de hacer esto dentro del marco.

Answer 1

Ahora JUnit4 está disponible a través de Android SDK (consulte el android-test-kit )

Actualización : ahora es oficial en d.android.com :

AndroidJUnitRunner es un nuevo corredor de pruebas desglosado para Android, que es parte de la Biblioteca de pruebas de soporte de Android y se puede descargar a través del repositorio de soporte de Android. El nuevo corredor contiene todas las mejoras de GoogleInstrumentationTestRunner y agrega más funciones:

• Soporte JUnit4
• Registro de Instrumentación para acceder a Instrumentación, Contexto y Argumentos del Paquete
• Filtros de prueba @SdkSupress y @RequiresDevice
• Tiempos de espera de prueba
• Sharding de pruebas
• Soporte RunListener para engancharse en el ciclo de vida de ejecución de prueba
• Mecanismo de supervisión de la actividad ActivityLifecycleMonitorRegistry

Entonces, el estilo JUnit4 de prueba de excepción usando la anotación esperada:

@Test(expected= IndexOutOfBoundsException.class) 
public void empty() { 
     new ArrayList<Object>().get(0); 
}

o reglas de excepción esperadas:

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

@Test
public void shouldTestExceptionMessage() throws IndexOutOfBoundsException {
    List<Object> list = new ArrayList<Object>();

    thrown.expect(IndexOutOfBoundsException.class);
    thrown.expectMessage("Index: 0, Size: 0");
    list.get(0); // execution will never get past this line
}

también es posible

Consulte la d.android.com para obtener más detalles sobre cómo configurar la biblioteca de soporte de prueba.

Answer 2

He estado buscando algunas buenas soluciones, sin embargo, ninguna de las soluciones fue realmente satisfactoria para mí. Entonces, creé el mío.

public final void assertThrows(VoidFunction v, Class<? extends Exception> e) {
    try {
        v.call();
    } catch (Exception ex) {
        if (!ex.getClass().equals(e)) {
            Assert.fail();
        }
        // Do nothing, basically succeeds test if same exception was thrown.
        return;
    }

    // Fails if no exception is thrown by default.
    Assert.fail();
}

Donde VoidFunction es una interfaz simple:

@FunctionalInterface
public interface VoidFunction {
    void call();
}

Esto se usa de la siguiente manera (por ejemplo):

@Test
public void testFoo() {
    assertThrows(() -> foo.bar(null)), NullPointerException.class);
    assertThrows(() -> foo.setPositiveInt(-5)), IllegalArgumentException.class);
    assertThrows(() -> foo.getObjectAt(-100)), IndexOutOfBoundsException.class);
    assertThrows(new VoidFunction() {
            @Override
            public void call() {
                foo.getObjectAt(-100);
            }
        }, IndexOutOfBoundsException.class); // Success
    assertThrows(new VoidFunction() {
                @Override
                public void call() {
                    throw new Exception();
                }
            }, NullPointerException.class); // Fail

}

Incluí una llamada sin usar la lambda, esto hace que sea más fácil de entender el código a veces, al menos para mí. Fácil de usar y permite múltiples capturas de excepción en UN método.

Answer 3

La expresión estándar junit 3 para este tipo de prueba fue:

public void testThatMethodThrowsException()
{
  try
  {
    doSomethingThatShouldThrow();
    Assert.fail("Should have thrown Arithmetic exception");
  }
  catch(ArithmeticException e)
  {
    //success
  }
}