Tests über Befehlszeile durchführen

In diesem Dokument wird beschrieben, wie Sie Tests direkt über die Befehlszeile ausführen. Dieses wird vorausgesetzt, dass Sie bereits wissen, wie Sie eine Android-App erstellen und Schreiben von Tests für Ihre App. Weitere Informationen zum Erstellen von Tests für Ihre finden Sie unter Apps unter Android testen.

Wenn Sie Ihre App mit dem Gradle-Build-System erstellen, gibt der Android-Gradle-Plug-in Plug-in können Sie Tests über Ihren Gradle-Plug-in Projekt über die Befehlszeile ausführen. Für eine genauere Kontrolle können Sie Führen Sie Ihre Tests über eine Android Debug Bridge (adb)-Shell. Dies kann nützlich sein, wenn Tests in einem Continuous Integration-Umgebung.

Erfahren Sie, wie Sie automatisierte instrumentierte Tests über die Befehlszeile mit virtuelle Geräte, die Gradle für Sie verwaltet, siehe Tests mit Gradle skalieren Verwaltete Geräte

Tests mit Gradle ausführen

Mit dem Android-Gradle-Plug-in kannst du Tests in deinem Gradle-Projekt mithilfe der Befehlszeile.

In der folgenden Tabelle wird zusammengefasst, wie Sie Ihre Tests mit Gradle ausführen:

Tabelle 1 Verschiedene Möglichkeiten zur Durchführung von Tests mit Logo: Gradle

Einheitentesttyp Auszuführender Befehl Speicherort des Testergebnisses
Test lokaler Einheiten Führen Sie die Aufgabe test aus: 

./gradlew test
HTML-Testergebnisdateien:
path_to_your_project/module_name/build/reports/tests/ -Verzeichnis.

XML-Testergebnisdateien:
path_to_your_project/module_name/build/test-results/ -Verzeichnis.

Instrumentierter Einheitentest Führen Sie die Aufgabe connectedAndroidTest aus: 

./gradlew connectedAndroidTest
HTML-Testergebnisdateien:
path_to_your_project/module_name/build/reports/androidTests/connected/ -Verzeichnis.

XML-Testergebnisdateien:
path_to_your_project/module_name/build/outputs/androidTest-results/connected/ -Verzeichnis.

Gradle unterstützt Abkürzungen für Aufgabennamen. Zum Beispiel können Sie die Aufgabe connectedAndroidTest initiieren, indem Sie und geben Sie den folgenden Befehl ein:

./gradlew cAT

Sie können auch die Gradle-Aufgaben check und connectedCheck ausführen. Diese werden für Aufgaben lokale bzw. instrumentierte Tests ausgeführt. Schließen Sie weitere Prüfungen ein, die von anderen Gradle-Plug-ins hinzugefügt wurden.

Tests für ein Modul ausführen

Mit den Aufgaben test und connectedAndroidTest werden Tests für jedes Modul in Ihrem Projekt arbeiten. Sie können Tests für ein bestimmtes Modul der Aufgabe test oder connectedAndroidTest den Modulnamen und einen Doppelpunkt (:). Mit dem folgenden Befehl werden beispielsweise instrumentierte Tests nur für das Modul mylibrary:

./gradlew mylibrary:connectedAndroidTest

Tests für eine Build-Variante ausführen

Die Aufgaben test und connectedAndroidTest führen jeweils Tests aus Build-Variante in Ihrem Projekt. Sie können ein Targeting auf bestimmte Build-Variante mit der folgenden Syntax:

  • Für lokale Einheitentests: 
    ./gradlew testVariantNameUnitTest
  • Für instrumentierte Tests: 
    ./gradlew connectedVariantNameAndroidTest

Bestimmte Testmethoden oder -klassen ausführen

Beim Ausführen lokaler Einheitentests können Sie mit Gradle bestimmte Tests mithilfe von Das Flag --tests. Der folgende Befehl führt beispielsweise nur den sampleTestMethod Tests für die angegebene Build-Variante. Weitere Informationen über mit dem Flag --tests können Sie die Gradle-Dokumentation Testfilter.


./gradlew testVariantNameUnitTest --tests '*.sampleTestMethod'

Tests mit ADB durchführen

Wenn Sie über die Befehlszeile Tests mit Android Debug Bridge ausführen (ADB) gibt es weitere Optionen für die auszuführenden Tests auswählen als bei jeder anderen Methode. Sie können einzelne Personen Testmethoden, filtern Sie Tests gemäß einer benutzerdefinierten Annotation oder geben Sie Tests an Optionen. Da der Testlauf vollständig über die Befehlszeile gesteuert wird, können Sie Ihre Tests mit Shell-Scripts auf verschiedene Arten anpassen.

Wenn Sie einen Test über die Befehlszeile ausführen möchten, führen Sie adb shell aus, um eine Befehlszeile zu starten Shell auf Ihrem Gerät oder Emulator. Innerhalb dieser Shell können Sie mit dem Aktivitätsmanager Verwenden Sie den Befehl am und den Unterbefehl instrument, um Ihre Tests auszuführen.

Sie können aber auch eine ADB-Shell starten, am instrument aufrufen und Befehlszeilen-Flags in einer einzigen Eingabezeile. Die Shell wird auf dem Gerät oder Emulatoren, führt Ihre Tests aus, generiert eine Ausgabe und kehrt dann zur Befehlszeile zurück auf Ihrem Computer.

So führen Sie einen Test mit am instrument aus:

  1. Ihre Hauptanwendung erstellen oder neu erstellen und Testpaket.
  2. Installieren Sie das Testpaket und die Hauptversion. Android-App-Paketdateien (APK-Dateien) auf Ihr aktuelles Android-Gerät oder Emulator.

  3. Geben Sie in der Befehlszeile Folgendes ein:

    adb shell am instrument -w <test_package_name>/<runner_class>

    Dabei ist <test_package_name> der Android-Paketname Ihres Tests. App und <runner_class> ist der Name der Android-Test-Runner-Klasse. die Sie verwenden. Der Android-Paketname ist der Wert des Manifest-Elements Paketattribut in der Manifestdatei deines Testpakets (AndroidManifest.xml) angegeben.

    Die Android Test Runner-Klasse ist normalerweise AndroidJUnitRunner:

    adb shell am instrument -w com.android.example/androidx.test.runner.AndroidJUnitRunner

Deine Testergebnisse werden auf STDOUT angezeigt.

Flaggen für Instrumente

So rufen Sie eine Liste aller Flags auf, die für den Befehl am instrument verwendet werden sollen: führen Sie adb shell am help aus. Einige wichtige Flags werden in den folgende Tabelle:

Tabelle 2: Wichtig: am instrument Flags

Melden Wert Beschreibung
-w (keine) Erzwingt am instrument, auf die Instrumentierung zu warten endet, bevor er sich selbst kündigt. Dadurch bleibt die bis die Tests beendet sind. Dieses Flag ist erforderlich, um um die Ergebnisse Ihrer Tests zu sehen.
-r (keine) Gibt die Ergebnisse im Rohformat aus. Verwenden Sie dieses Flag, wenn Sie zu erfassen, sodass sie nicht als Testergebnissen. Dieses Flag ist für die Verwendung mit dem Flag vorgesehen. -e perf true (dokumentiert im am instrument options) an.
-e <test_options> Stellt Testoptionen als Schlüssel/Wert-Paare bereit. Die Das am instrument-Tool übergibt diese an die angegebene Instrumentierungsklasse mithilfe ihrer onCreate() . Sie können angeben, dass -e <test_options> Die Schlüssel und Werte sind in den am instrument options auf. Sie können diese Schlüssel/Wert-Paare nur AndroidJUnitRunner oder mit InstrumentationTestRunner und ihre abgeleiteten Klassen. Ihre Verwendung mit einer anderen Klasse hat keine Auswirkungen.
--no-hidden-api-checks (keine) Deaktiviert die Einschränkungen für die Verwendung versteckter APIs. Weitere Informationen Informationen dazu, was verborgene APIs sind und wie sich das auf Ihre App, lesen Einschränkungen für Nicht-SDK-Schnittstellen:

AM Instrument-Optionen

Das am instrument-Tool übergibt die Testoptionen an AndroidJUnitRunner oder InstrumentationTestRunner in Form von Schlüssel/Wert-Paaren unter Verwendung des Flags -e und der folgenden Syntax:

-e <key> <value>

Für einige Schlüssel sind mehrere Werte zulässig. Sie geben mehrere Werte in einem kommagetrennte Liste. Dieser Aufruf von AndroidJUnitRunner stellt mehrere Werte für den Schlüssel package bereit:

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

In der folgenden Tabelle sind die Schlüssel/Wert-Paare aufgeführt, die Sie mit dem Test-Runner verwenden können:

Tabelle 3 -e die Schlüssel/Wert-Paare zur Verwendung mit Test-Runner

Schlüssel Wert Beschreibung
package <Java_package_name> Der voll qualifizierte Java-Paketname für einen der Pakete in der Testanwendung. Jede Testlaufklasse, die diese Methode verwendet Paketname ausgeführt wird. Beachten Sie, dass dies kein Paketname Android enthält ein Testpaket Android-Paketname, kann aber mehrere Java-Pakete enthalten
class <class_name> Der voll qualifizierte Name der Java-Klasse für einen der Testfälle Klassen. Nur diese Testlaufklasse wird ausgeführt.
<class_name>#method name Ein voll qualifizierter Name der Testlaufklasse und eine ihrer Methoden. Nur wird diese Methode ausgeführt. Achten Sie auf das Rautezeichen (#) zwischen den Klassen und den Namen der Methode.
func true Führt alle Testklassen aus, die InstrumentationTestCase
unit true Führt alle Testklassen aus, die keine InstrumentationTestCase oder PerformanceTestCase.
size [small | medium | large] Führt eine mit der Größe annotierte Testmethode aus. Die Anmerkungen sind @SmallTest, @MediumTest und @LargeTest
perf true Führt alle Testklassen aus, die implementieren PerformanceTestCase Wenn Sie diese Option verwenden, geben Sie das Flag -r für am instrument, damit die Ausgabe im Rohformat beibehalten wird und nicht als Testergebnisse neu formatiert werden.
debug true Führt Tests im Debug-Modus aus.
log true Lädt und protokolliert alle angegebenen Tests, führt sie aber nicht aus. Der Test Informationen erscheinen in STDOUT. Hiermit bestätigen Kombinationen anderer Filter und Testspezifikationen.
emma true Führt eine Analyse der EMMA-Codeabdeckung durch und schreibt die Ausgabe in /data/<app_package>/coverage.ec auf dem Gerät. Bis Dateispeicherort überschreiben, Schlüssel coverageFile verwenden die im folgenden Eintrag beschrieben wird.

Hinweis:Für diese Option ist ein EMMA-instrumentiert. der Testanwendung, die Sie mit dem Ziel: coverage.

coverageFile <filename> Überschreibt den Standardspeicherort der EMMA-Abdeckungsdatei im . Geben Sie diesen Wert als Pfad und Dateiname im UNIX-Format an. Der Standarddateiname wird im Eintrag für die emma-Schlüssel.

Beachten Sie Folgendes, wenn Sie das Flag -e verwenden:

  • am instrument-Aufrufe onCreate(Bundle) mit einem Bundle, der das Schlüssel/Wert-Paar Paare.
  • Der Schlüssel package hat Vorrang vor dem Schlüssel class. Wenn Sie eine Paket und geben dann separat eine Klasse in diesem Paket an, führt alle Tests im Paket aus und ignoriert den Klassenschlüssel.
  • Der Schlüssel func und der Schlüssel unit schließen sich gegenseitig aus.

Beispiele für die Verwendung

Die folgenden Abschnitte enthalten Beispiele für die Verwendung von am instrument zum Ausführen von Tests. Sie basieren auf der folgenden Struktur:

  • Das Testpaket hat den Android-Paketnamen com.android.demo.app.tests.
  • Zwei instrumentierte Testklassen: <ph type="x-smartling-placeholder">
      </ph>
    • TestClass1, die die Testmethode testMethod1 enthält.
    • TestClass2 mit den Testmethoden testMethod2 und testMethod3.
  • Der Test-Runner ist AndroidJUnitRunner

Gesamtes Testpaket ausführen

Um alle Testklassen im Testpaket auszuführen, geben Sie Folgendes ein:

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

Alle Tests in einer Testlaufklasse ausführen

Um alle Tests in der Klasse TestClass1 auszuführen, geben Sie Folgendes ein:

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

Teilmenge von Tests auswählen

So führen Sie alle Tests in der Klasse TestClass1 und der Methode testMethod3 in TestClass2 aus: Geben Sie Folgendes ein:

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

Weitere Anwendungsfälle finden Sie in der AndroidJUnitRunner API-Referenz