Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.

Cómo realizar pruebas desde la línea de comandos

En este documento, se describe cómo crear y ejecutar pruebas directamente desde la línea de comandos. Se asume que ya sabes cómo crear una aplicación para Android en tu entorno de programación.

Cómo ejecutar pruebas

Puedes ejecutar pruebas desde la línea de comandos, con Gradle o con una shell de Android Debug Bridge (adb).

El complemento de Android para Gradle permite ejecutar pruebas de unidades desde el proyecto de Gradle mediante la línea de comandos. Si quieres obtener más información para compilar pruebas de unidades para tu app, consulta Cómo compilar pruebas de unidades efectivas.

Cómo ejecutar pruebas de unidades con Gradle

El complemento de Android para Gradle permite ejecutar pruebas de unidades desde el proyecto de Gradle mediante la línea de comandos. Si quieres obtener más información para compilar pruebas de unidades para tu app, consulta Cómo compilar pruebas de unidades efectivas.

En la siguiente tabla, se resume cómo ejecutar pruebas de unidades con Gradle:

Tipo de prueba de unidad Comando para ejecutar Ubicación del resultado de la prueba
Prueba de unidad local Llama a la tarea test:

./gradlew test
Archivos de resultados de prueba HTML: directorio path_to_your_project/module_name/build/reports/tests/.

Archivos de resultados de pruebas XML: directorio path_to_your_project/module_name/build/test-results/.

Prueba de unidad instrumentada Llama a la tarea connectedAndroidTest:

./gradlew connectedAndroidTest
Archivos de resultados de prueba HTML: directorio path_to_your_project/module_name/build/reports/androidTests/connected/.

Archivos de resultados de pruebas XML: directorio path_to_your_project/module_name/build/outputs/androidTest-results/connected/.

Gradle admite abreviaturas de nombres de tareas. Eso significa que, por ejemplo, puedes iniciar directamente la tarea connectedAndroidTest con el siguiente comando.

./gradlew cAT

Las tareas test y connectedAndroidTest ejecutan pruebas en cada módulo y variante de compilación del proyecto. Puedes ejecutar pruebas para un módulo específico del proyecto agregando como prefijo las tareas test o connectedAndroidTest con el nombre del módulo y dos puntos (:). Por ejemplo, el siguiente comando ejecuta pruebas de unidades instrumentadas solo para el módulo mylibrary.

./gradlew mylibrary:connectedAndroidTest

También puedes orientar una variante de compilación específica mediante la siguiente sintaxis.

  • Para pruebas de unidades locales:
    ./gradlew testVariantNameUnitTest
    
  • Para pruebas de unidades instrumentadas:
    ./gradlew connectedVariantNameAndroidTest
    

Nota: Si no especificas un módulo objetivo para pruebas, Gradle buscará en todos los módulos y ejecutará pruebas para cada variante que coincida con el nombre de configuración que especifiques.

Gradle también permite orientar pruebas específicas mediante la marca --tests. Por ejemplo, el siguiente comando ejecuta solo las pruebas de sampleTestMethod para la variante de compilación especificada. Para obtener más información sobre el uso de la marca --tests, consulta la documentación de Gradle sobre el filtrado de pruebas.

./gradlew testVariantNameUnitTest --tests *.sampleTestMethod

Informes de varios módulos

Como se describe en la Tabla 1, Gradle guarda los informes en el directorio build/ de cada módulo que prueba. Sin embargo, si se ejecutan pruebas en varios módulos, podría resultar útil combinar todos los resultados en un único informe. Para generar un único informe cuando se ejecutan pruebas en varios módulos, sigue estos pasos:

  1. En el archivo build.gradle a nivel del proyecto, agrega lo siguiente debajo de las demás configuraciones del archivo.
    apply plugin: 'android-reporting'
    
  2. Invoca la tarea test o connectedAndroidTest con la tarea mergeAndroidReports. Por ejemplo:
    ./gradlew connectedAndroidTest mergeAndroidReports
    

    Si deseas omitir las fallas para que Gradle termine de ejecutar el resto de las pruebas, agrega la opción --continue:

    ./gradlew connectedAndroidTest mergeAndroidReports --continue
    

Cuando Gradle termina de ejecutar todas las pruebas, guarda los informes combinados en el directorio PATH_TO_YOUR_PROJECT/build/.

Cómo ejecutar pruebas con ADB

Cuando se ejecutan pruebas desde la línea de comandos con Android Debug Bridge (adb), se obtienen más opciones para seleccionar las pruebas que se ejecutarán con ese otro método. Puedes seleccionar métodos de prueba individuales, filtrar pruebas según la anotación o especificar opciones de prueba. Dado que la ejecución de pruebas se controla por completo desde la línea de comandos, puedes personalizar las pruebas con secuencias de comandos de shell de varias maneras.

Para ejecutar una prueba desde la línea de comandos, ejecuta adb shell para iniciar un shell de línea de comandos en el dispositivo o emulador y, luego, ejecuta el comando am instrument en el shell. Se controlan las pruebas y am con marcas en la línea de comandos.

A modo de atajo, puedes iniciar un shell de adb, llamar a am instrument y especificar marcas de línea de comandos, todo en una línea de entrada. Se abrirá el shell en el dispositivo o emulador, ejecutará las pruebas, generará el resultado y luego regresará a la línea de comandos de la computadora.

Para ejecutar una prueba con am instrument:

  1. Si es necesario, vuelve a compilar la aplicación principal y el paquete de prueba.
  2. Instala los archivos del paquete de prueba y del paquete de Android de la aplicación principal (archivos .apk) en el emulador o dispositivo Android actual.
  3. En la línea de comandos, ingresa:
    $ adb shell am instrument -w <test_package_name>/<runner_class>
    

    donde <test_package_name> es el nombre del paquete de Android de la aplicación de prueba, y <runner_class> es el nombre de la clase del ejecutor de pruebas de Android que estás usando. El nombre del paquete de Android es el valor del atributo package del elemento manifest correspondiente al archivo de manifiesto (AndroidManifest.xml) del paquete de prueba. Por lo general, la clase del ejecutor de pruebas de Android es AndroidJUnitRunner.

    Los resultados de la prueba se muestran en STDOUT.

Esta operación inicia un shell adb y, luego, ejecuta am instrument con los parámetros especificados. Esta forma particular del comando ejecuta todas las pruebas del paquete de pruebas. Para controlar este comportamiento, puedes pasar marcas a am instrument, que se describen en la próxima sección.

Cómo usar el comando am instrument

La sintaxis general del comando am instrument es la siguiente:

am instrument [flags] <test_package>/<runner_class>

Se describen en la siguiente tabla los parámetros de entrada principales de am instrument:

Parámetro Valor Descripción
<test_package> Es el nombre del paquete de Android correspondiente al paquete de prueba. Es el valor del atributo package del elemento manifest correspondiente al archivo de manifiesto del paquete de prueba.
<runner_class> Es el nombre de clase del ejecutor de pruebas instrumentado que estás usando. Por lo general, es AndroidJUnitRunner.

Se describen en la siguiente tabla las marcas de am instrument:

Marca Valor Descripción
-w (ninguno) Hace que am instrument espere hasta que finalice la instrumentación antes de terminar. El efecto neto es mantener el shell abierto hasta que hayan finalizado todas las pruebas. Esta marca no es obligatoria; sin embargo, si no la usas, no verás los resultados de las pruebas.
-r (ninguno) Los resultados se generan en un formato sin procesar. Usa esta marca cuando desees recopilar mediciones de rendimiento, de modo que no tengan el formato de los resultados de pruebas. Esta marca está diseñada para usarse junto con -e perf true (se documenta en la sección Opciones de instrumento).
-e <test_options> Proporciona opciones de prueba como pares clave-valor. La herramienta am instrument pasa estos pares a la clase de instrumentación especificada mediante el método onCreate(). Puedes especificar varios casos de -e <test_options>. Las claves y los valores se describen en la sección Opciones de am instrument. Solo puedes usar estos pares clave-valor con AndroidJUnitRunner o con InstrumentationTestRunner y sus subclases. Si se usan con cualquier otra clase, no tendrán efecto.
--no-hidden-api-checks (ninguno) Inhabilita las restricciones de uso de API ocultas. Para obtener más información sobre qué son las API ocultas y cómo esto puede afectar tu app, consulta Restricciones en interfaces que no pertenecen al SDK.

Opciones de am instrument

La herramienta am instrument pasa las opciones de prueba a AndroidJUnitRunner o a InstrumentationTestRunner en el formato de pares clave-valor, mediante la marca -e, con la siguiente sintaxis:

-e <key> <value>

Algunas claves aceptan múltiples valores. Debes especificar múltiples valores en una lista de valores separados por comas. Por ejemplo, esta invocación de AndroidJUnitRunner proporciona múltiples valores para la clave package:

$ adb shell am instrument -w -e package com.android.test.package1,com.android.test.package2 \
> com.android.test/android.support.test.runner.AndroidJUnitRunner

En la siguiente tabla, se muestran los pares clave-valor que puedes usar en el ejecutor de pruebas.

Clave Valor Descripción
package <Java_package_name> Es el nombre completamente calificado del paquete Java correspondiente a uno de los paquetes de la aplicación de prueba. Se ejecutan todas las clases de caso de prueba que usan este nombre de paquete. Ten en cuenta que este no es un nombre de paquete de Android. Un paquete de prueba tiene un solo nombre de paquete de Android, pero puede contener varios paquetes de Java.
class <class_name> Es el nombre completo de clase de Java correspondiente a una de las clases de caso de prueba. Solo se ejecuta esta clase de caso de prueba.
<class_name>#method name Es el nombre completo de clase de caso de prueba y uno de los métodos. Solo se ejecuta este método. Ten en cuenta la marca de hash (#) entre el nombre de la clase y el nombre del método.
func true Ejecuta todas las clases de prueba que amplían InstrumentationTestCase.
unit true Ejecuta todas las clases de prueba que no amplían InstrumentationTestCase ni PerformanceTestCase.
size [small | medium | large] Ejecuta un método de prueba con anotación de tamaño. Las anotaciones son @SmallTest, @MediumTest y @LargeTest.
perf true Ejecuta todas las clases de prueba que implementan PerformanceTestCase. Si usas esta opción, especifica también la marca -r para am instrument, de modo que se mantenga el resultado en formato RAW y que no se aplique el formato de resultados de prueba.
debug true Ejecuta pruebas en modo de depuración.
log true Carga y registra todas las pruebas especificadas, pero no las ejecuta. La información de pruebas aparece en STDOUT. Úsala para verificar las combinaciones de otros filtros y especificaciones de pruebas.
emma true Ejecuta un análisis de cobertura de código EMMA y escribe el resultado en el directorio /data/<app_package>/coverage.ec del dispositivo. Para anular la ubicación del archivo, usa la clave coverageFile que se describe en la siguiente entrada.

Nota: Esta opción requiere una compilación de la aplicación de prueba instrumentada por EMMA, que puedes generar con el objetivo coverage.

coverageFile <filename> Anula la ubicación predeterminada del archivo de cobertura de EMMA en el dispositivo. Especifica este valor como ruta de acceso y nombre de archivo en formato UNIX. El nombre de archivo predeterminado se describe en la entrada de la clave emma.
Notas de uso de la marca -e
  • am instrument invoca a onCreate(Bundle) con un Bundle que contiene los pares clave-valor.
  • La clave package tiene prioridad sobre la clave class. Si primero especificas un paquete y luego (de forma separada) una clase dentro del paquete, Android ejecutará todas las pruebas en el paquete y omitirá la clave class.
  • La claves func y unit son mutuamente excluyentes.

Ejemplos de uso

En las siguientes secciones, se proporcionan ejemplos de uso de am instrument para ejecutar pruebas. Los ejemplos se basan en la siguiente estructura:

  • El paquete de prueba tiene el nombre de paquete de Android com.android.demo.app.tests.
  • Dos clases de pruebas instrumentadas:
    • Foo1, que contiene el método de prueba bar1.
    • Foo2, que contiene los métodos de prueba bar2 y bar3.
  • El ejecutor de pruebas es AndroidJUnitRunner.

Cómo ejecutar el paquete de prueba completo

Para ejecutar todas las clases de prueba en el paquete de prueba, ingresa:

$ adb shell am instrument -w com.android.demo.app.tests/android.support.test.runner.AndroidJUnitRunner

Cómo ejecutar todas las pruebas en una clase de caso de prueba

Para ejecutar todas las pruebas de la clase UnitTests, ingresa:

$ adb shell am instrument -w  \
> -e class com.android.demo.app.tests.Foo \
> com.android.demo.app.tests/android.support.test.runner.AndroidJUnitRunner

am instrument obtiene el valor de la marca -e, detecta la palabra clave class y ejecuta todos los métodos de la clase UnitTests.

Cómo seleccionar un subconjunto de pruebas

Para ejecutar todas las pruebas en Foo1 y el método bar3 en Foo2, ingresa:

$ adb shell am instrument -w \
> -e class com.android.demo.app.tests.Foo1,com.android.demo.app.tests.Foo2#bar3 \
> com.android.demo.app.tests/android.support.test.runner.AndroidJUnitRunner