Questo documento descrive come eseguire i test direttamente dalla riga di comando. Questo documento presuppone che tu sappia già come creare un'app per Android e scrivere test per la tua app. Per ulteriori informazioni su come creare test per la tua app, consulta l'articolo Testare le app su Android.
Quando crei la tua app utilizzando il sistema di build Gradle, il plug-in Android Gradle ti consente di eseguire test dal tuo progetto Gradle utilizzando la riga di comando. Per un controllo più granulare, puoi scegliere di eseguire i test tramite una shell di Android Debug Bridge (adb). Questo può essere utile durante l'esecuzione di test in un ambiente di integrazione continua.
Per scoprire come eseguire test strumentati automatizzati dalla riga di comando utilizzando i dispositivi virtuali gestiti da Gradle per te, consulta Scalare i test con i dispositivi gestiti da Gradle.
Esecuzione di test con Gradle
Il plug-in Android per Gradle consente di eseguire test dal progetto Gradle utilizzando la riga di comando.
La tabella riportata di seguito riassume come eseguire i test con Gradle:
Tabella 1. Diversi modi di eseguire i test con Gradle
Tipo di test delle unità | Comando da eseguire | Località del risultato del test |
---|---|---|
Test delle unità locali |
Esegui l'attività test :
|
File dei risultati del test HTML:path_to_your_project/module_name/build/reports/tests/
directory.
File XML dei risultati del test: |
Test delle unità strumentale |
Esegui l'attività connectedAndroidTest :
|
File dei risultati del test HTML:path_to_your_project/module_name/build/reports/androidTests/connected/
directory.
File XML dei risultati del test: |
Gradle supporta le abbreviazioni dei nomi delle attività.
Ad esempio, puoi avviare l'attività connectedAndroidTest
inserendo il seguente comando:
./gradlew cAT
Puoi anche scegliere di eseguire le attività Gradle check
e connectedCheck
. Queste attività eseguono rispettivamente test locali o strumentati, ma includono altri controlli aggiunti da altri plug-in Gradle.
Eseguire test su un modulo
Le attività test
e connectedAndroidTest
eseguono test su ogni modulo nel tuo progetto. Puoi eseguire test su un modulo specifico anteponendo all'attività test
o connectedAndroidTest
il nome del modulo e i due punti (:). Ad esempio, il seguente comando esegue i test strumentati solo per il modulo mylibrary
:
./gradlew mylibrary:connectedAndroidTest
Esegui test su una variante della build
Le attività test
e connectedAndroidTest
eseguono test su ogni
variante della build nel tuo progetto. Puoi scegliere come target una variante di build specifica utilizzando la seguente sintassi:
- Per i test delle unità locali:
./gradlew testVariantNameUnitTest
- Per i test strumentati:
./gradlew connectedVariantNameAndroidTest
Eseguire metodi o classi di test specifici
Quando si eseguono test delle unità locali, Gradle consente di scegliere come target test specifici utilizzando il flag --tests
. Ad esempio, il seguente comando esegue solo i test sampleTestMethod
per la variante di build specificata. Per scoprire di più sull'utilizzo del flag --tests
, leggi la documentazione di Gradle sui filtri di test.
./gradlew testVariantNameUnitTest --tests '*.sampleTestMethod'
Report multimodulo per test strumentati
Come descritto nella tabella 1, Gradle salva i risultati dei test strumentati nella directory build/
di ogni modulo che testa. Tuttavia, quando si eseguono test su più moduli, può essere utile combinare tutti i risultati del test in un unico report. Per generare un singolo report quando esegui test su più moduli, procedi nel seguente modo:
Nel file
build.gradle
a livello di progetto, aggiungi quanto segue dopo il bloccobuildscript{}
:Trendy
apply plugin: 'android-reporting'
Kotlin
apply(plugin = "android-reporting")
Richiama l'attività
test
oconnectedAndroidTest
con l'attivitàmergeAndroidReports
. Ecco alcuni esempi:./gradlew connectedAndroidTest mergeAndroidReports
Per saltare gli errori dei test in modo che Gradle termini tutti i test rimanenti, aggiungi l'opzione
--continue
:./gradlew connectedAndroidTest mergeAndroidReports --continue
Al termine dell'esecuzione dei test, Gradle salva i risultati combinati nella directory path_to_your_project/build/
.
Esegui test con ADB
Quando esegui i test dalla riga di comando con Android Debug Bridge (adb), le opzioni per scegliere i test da eseguire sono più numerose rispetto a qualsiasi altro metodo. Puoi selezionare singoli metodi di test, filtrare i test in base a un'annotazione personalizzata o specificare opzioni di test. Poiché l'esecuzione del test è controllata interamente dalla riga di comando, puoi personalizzare i test con gli script shell in vari modi.
Per eseguire un test dalla riga di comando, esegui adb shell
per avviare una shell della riga di comando sul tuo dispositivo o emulatore. All'interno della shell puoi interagire con activity Manager utilizzando il comando am
e usare il relativo sottocomando instrument
per eseguire i test.
Come scorciatoia, puoi avviare una shell adb, chiamare am instrument
e specificare flag della riga di comando, il tutto su un'unica riga di input. La shell si apre sul dispositivo o sull'emulatore, esegue i test, produce un output e poi torna alla riga di comando sul computer.
Per eseguire un test con am instrument
:
- Crea o ricrea l'applicazione principale e il pacchetto di test.
- Installa il pacchetto di test e i file dei pacchetti Android principali (file APK) dell'applicazione nel tuo emulatore o dispositivo Android corrente.
Nella riga di comando, inserisci:
adb shell am instrument -w <test_package_name>/<runner_class>
Dove
<test_package_name>
è il nome del pacchetto Android della tua applicazione di test e<runner_class>
è il nome della classe Android Test runner che stai utilizzando. Il nome del pacchetto Android è il valore dell'attributo pacchetto dell'elemento manifest nel file manifest del tuo pacchetto di test (AndroidManifest.xml
).La classe dell'esecutore del test di Android è in genere
AndroidJUnitRunner
:adb shell am instrument -w com.android.example/androidx.test.runner.AndroidJUnitRunner
I risultati del test vengono visualizzati in STDOUT
.
bandiere strumentali
Per trovare un elenco di tutti i flag da utilizzare con il comando am instrument
, esegui adb shell am help
. Alcuni indicatori importanti sono descritti nella seguente tabella:
Tabella 2. Flag am instrument
importanti
Segnala | Valore | Descrizione |
---|---|---|
-w
|
(nessuno) |
Forza am instrument ad attendere la chiusura della strumentazione
prima di terminarla. In questo modo la shell rimane aperta fino al termine dei test. Questo flag è necessario per visualizzare i risultati dei test.
|
-r
|
(nessuno) |
Restituisce i risultati in formato non elaborato. Utilizza questo flag quando vuoi raccogliere
misurazioni delle prestazioni in modo che non siano formattate come
risultati del test. Questo flag è progettato per l'utilizzo con il flag -e perf true (documentato nella sezione Opzioni strumenti AM).
|
-e
|
<test_options>
|
Fornisce opzioni di test sotto forma di coppie chiave-valore. Lo strumento am instrument le passa alla classe di strumentazione specificata utilizzando il metodo onCreate() . Puoi specificare più occorrenze di -e <test_options> . Le chiavi e i valori sono descritti nella sezione relativa alle opzioni dello strumento AM. Puoi
utilizzare queste coppie chiave-valore solo con
AndroidJUnitRunner
o con InstrumentationTestRunner
e le relative sottoclassi. Il loro utilizzo con qualsiasi altro corso non ha alcun effetto.
|
--no-hidden-api-checks
|
(nessuno) | Disabilita le limitazioni all'uso di API nascoste. Per saperne di più su cosa sono le API nascoste e su come possono influire sulla tua app, consulta la pagina Restrizioni sulle interfacce non SDK. |
opzioni strumento am
Lo strumento am instrument
passa le opzioni di test a AndroidJUnitRunner
o InstrumentationTestRunner
sotto forma di coppie chiave-valore, utilizzando il flag -e
, con questa sintassi:
-e <key> <value>
Alcune chiavi accettano più valori. Si specificano più valori in
un elenco separato da virgole. Ad esempio, questa chiamata di AndroidJUnitRunner
fornisce più valori per la chiave package
:
adb shell am instrument -w -e package com.android.test.package1,com.android.test.package2 \
> com.android.test/androidx.test.runner.AndroidJUnitRunner
Nella tabella seguente sono elencate le coppie chiave-valore che puoi utilizzare con l'esecutore del test:
Tabella 3. -e contrassegneremo le coppie chiave-valore da usare con l'esecutore del test
Chiave | Valore | Descrizione |
---|---|---|
package
|
<Java_package_name>
|
Il nome del pacchetto Java completo per uno dei pacchetti nell'applicazione di test. Viene eseguita qualsiasi classe dello scenario di test che utilizza questo nome pacchetto. Tieni presente che questo non è il nome di un pacchetto Android; un pacchetto di test ha un solo nome di pacchetto Android, ma al suo interno potrebbe contenere diversi pacchetti Java. |
class |
<class_name> |
Il nome completo della classe Java per una delle classi dello scenario di test. Viene eseguita solo questa classe dello scenario di test. |
<class_name>#method name |
Il nome completo della classe dello scenario di test e uno dei relativi metodi. Viene eseguito solo questo metodo. Nota il marcatore hash (#) tra il nome della classe e quello del metodo. | |
func |
true |
Esegue tutte le classi di test che estendono InstrumentationTestCase .
|
unit |
true |
Esegue tutte le classi di test che non estendono
InstrumentationTestCase o
PerformanceTestCase .
|
size |
[small | medium | large ]
|
Esegue un metodo di test annotato in base alle dimensioni. Le annotazioni sono
@SmallTest , @MediumTest e
@LargeTest .
|
perf |
true |
Esegue tutte le classi di test che implementano
PerformanceTestCase .
Quando utilizzi questa opzione, specifica il flag -r per
am instrument in modo che l'output venga mantenuto in formato non elaborato
e non venga riformattato come risultati del test.
|
debug |
true |
Esegue test in modalità di debug. |
log |
true |
Carica e registra tutti i test specificati, ma non li esegue. Le informazioni del test vengono visualizzate in STDOUT . Utilizzalo per verificare le combinazioni di altri filtri e le specifiche di test.
|
emma |
true |
Esegue un'analisi della copertura del codice EMMA e scrive l'output in
/data/<app_package>/coverage.ec sul dispositivo. Per eseguire l'override della posizione del file, utilizza la chiave coverageFile descritta nella voce seguente.
Nota: questa opzione richiede una build dell'applicazione di test basata su EMMA, che puoi generare con il target |
coverageFile |
<filename> |
Esegue l'override della posizione predefinita del file di copertura EMMA sul dispositivo. Specifica questo valore come percorso e nome file in formato UNIX.
Il nome file predefinito è descritto nella voce relativa alla
chiave emma .
|
Quando utilizzi il flag -e
, tieni presente quanto segue:
am instrument
chiamaonCreate(Bundle)
con unaBundle
contenente le coppie chiave-valore.- La chiave
package
ha la precedenza sulla chiaveclass
. Se specifichi un pacchetto e specifichi separatamente una classe all'interno del pacchetto, Android esegue tutti i test nel pacchetto e ignora la chiave della classe. - La chiave
func
e la chiaveunit
si escludono a vicenda.
Esempi di utilizzo
Le seguenti sezioni forniscono esempi di utilizzo di am instrument
per l'esecuzione dei test.
Si basano sulla seguente struttura:
- Il pacchetto di test ha il nome di pacchetto Android
com.android.demo.app.tests
. - Due classi di test strumentati:
TestClass1
, che contiene il metodo di testtestMethod1
.TestClass2
, che contiene i metodi di testtestMethod2
etestMethod3
.
- L'esecutore del test è
AndroidJUnitRunner
.
Esegui l'intero pacchetto di test
Per eseguire tutte le classi di test nel pacchetto di test, inserisci:
adb shell am instrument -w com.android.demo.app.tests/androidx.test.runner.AndroidJUnitRunner
Esegui tutti i test in una classe dello scenario di test
Per eseguire tutti i test nella classe TestClass1
, inserisci:
adb shell am instrument -w \
> -e class com.android.demo.app.tests.TestClass1 \
> com.android.demo.app.tests/androidx.test.runner.AndroidJUnitRunner
Seleziona un sottoinsieme di test
Per eseguire tutti i test nella classe TestClass1
e il metodo testMethod3
in TestClass2
,
inserisci:
adb shell am instrument -w \
> -e class com.android.demo.app.tests.TestClass1,com.android.demo.app.tests.TestClass2#testMethod3 \
> com.android.demo.app.tests/androidx.test.runner.AndroidJUnitRunner
Puoi trovare altri casi d'uso nel
riferimento dell'API
AndroidJUnitRunner
.