AndroidJUnitRunner

La classe AndroidJUnitRunner est un lanceur de test JUnit qui vous permet d'exécuter des tests JUnit 4 instrumentés sur des appareils Android ; y compris ceux qui utilisent Espresso, UI Automator et Compose. cadres de test.

Remarque :AndroidJUnitRunner n'est pas nécessaire pour les tests en local. En savoir plus sur les différence entre les tests instrumentés et les tests en local dans les Principes de base des tests.

Le lanceur de test gère le chargement de votre package de test et de l'application testée dans un l'appareil, l'exécution des tests et la création de rapports sur leurs résultats.

Ce lanceur de test accepte plusieurs tâches de test courantes, y compris les suivantes:

• Écrire des tests JUnit
• Accéder au contexte de l'application
• Filtrer les tests
• Tests de segmentation

Écrire des tests JUnit

L'extrait de code suivant montre comment écrire un JUnit 4 instrumenté pour vérifier que l'opération changeText dans ChangeTextBehavior fonctionne correctement:

Kotlin

@RunWith(AndroidJUnit4::class) // Only needed when mixing JUnit 3 and 4 tests
@LargeTest // Optional runner annotation
class ChangeTextBehaviorTest {
 val stringToBeTyped = "Espresso"
 // ActivityTestRule accesses context through the runner
 @get:Rule
 val activityRule = ActivityTestRule(MainActivity::class.java)

 @Test fun changeText_sameActivity() {
 // Type text and then press the button.
 onView(withId(R.id.editTextUserInput))
 .perform(typeText(stringToBeTyped), closeSoftKeyboard())
 onView(withId(R.id.changeTextBt)).perform(click())

 // Check that the text was changed.
 onView(withId(R.id.textToBeChanged))
 .check(matches(withText(stringToBeTyped)))
 }
}

Java

@RunWith(AndroidJUnit4.class) // Only needed when mixing JUnit 3 and 4 tests
@LargeTest // Optional runner annotation
public class ChangeTextBehaviorTest {

    private static final String stringToBeTyped = "Espresso";

    @Rule
    public ActivityTestRule<MainActivity>; activityRule =
            new ActivityTestRule<>;(MainActivity.class);

    @Test
    public void changeText_sameActivity() {
        // Type text and then press the button.
        onView(withId(R.id.editTextUserInput))
                .perform(typeText(stringToBeTyped), closeSoftKeyboard());
        onView(withId(R.id.changeTextBt)).perform(click());

        // Check that the text was changed.
        onView(withId(R.id.textToBeChanged))
                .check(matches(withText(stringToBeTyped)));
    }
}

Remarque :Évitez de mélanger le code de test JUnit 3 et JUnit 4 dans le même package. car cela pourrait entraîner des résultats inattendus. Si vous créez un modèle classe de test JUnit 4 pour s'exécuter sur un appareil ou un émulateur, votre classe de test doit être précédée de l'annotation @RunWith(AndroidJUnit4::class) en Kotlin, qui en Java est @RunWith(AndroidJUnit4.class).

Accéder au contexte de l'application

Lorsque vous utilisez AndroidJUnitRunner pour exécuter vos tests, vous pouvez accéder au contexte pour l'application testée en appelant la fonction ApplicationProvider.getApplicationContext(). Si vous avez créé sous-classe de Application dans votre application, cette méthode renvoie votre le contexte de la sous-classe.

Si vous mettez en œuvre des outils, vous pouvez accéder à des API de test de bas niveau à l'aide de InstrumentationRegistry. Ce cours inclut les objet Instrumentation, l'objet Context de l'application cible, le test l'objet Context de l'application et les arguments de ligne de commande transmis dans votre test.

Filtrer les tests

Dans vos tests JUnit 4.x, vous pouvez utiliser des annotations pour configurer l'exécution du test. Ce réduit le besoin d'ajouter du code récurrent et conditionnel dans votre tests. En plus des annotations standards prises en charge par JUnit 4, le fichier de test Runner est également compatible avec les annotations spécifiques à Android, y compris les suivantes:

• @RequiresDevice: indique que le test ne doit être exécuté que sur des appareils et non sur des émulateurs.
• @SdkSuppress: empêche l'exécution du test sur une API Android inférieure. niveau que le niveau donné. Par exemple, pour supprimer les tests sur tous les niveaux d'API inférieurs de 23, utilisez l'annotation @SDKSuppress(minSdkVersion=23).
• @SmallTest, @MediumTest et @LargeTest: classez la durée d'un test. et, par conséquent, à quelle fréquence vous pouvez exécuter le test. Toi vous pouvez utiliser cette annotation pour filtrer les tests à exécuter, en définissant Propriété android.testInstrumentationRunnerArguments.size:

-Pandroid.testInstrumentationRunnerArguments.size=small

Tests de segment

Si vous avez besoin de charger en parallèle l'exécution de vos tests, en les partageant plusieurs serveurs pour les rendre plus rapides, vous pouvez les diviser en groupes ou segments. Le lanceur de test permet de diviser une suite de tests en plusieurs segments, ce qui vous permet d'exécuter facilement des tests appartenant au même segment groupe. Chaque segment est identifié par un numéro d'index. Lorsque vous exécutez des tests, utilisez la l'option -e numShards pour spécifier le nombre de segments distincts à créer et la -e shardIndex pour spécifier le segment à exécuter.

Par exemple, pour diviser la suite de tests en 10 segments et exécuter uniquement les tests dans le deuxième segment, utilisez la commande adb suivante:

adb shell am instrument -w -e numShards 10 -e shardIndex 2

Utiliser Android Test Orchestrator

Android Test Orchestrator vous permet d'exécuter chacun des tests de votre application dans son propre appel de Instrumentation. Lorsque vous utilisez AndroidJUnitRunner version 1.0 ou une version ultérieure, vous avez accès à Android Test Orchestrator.

Android Test Orchestrator offre les avantages suivants pour vos tests environnement:

• État partagé minimal:chaque test s'exécute dans son propre Instrumentation. Compute Engine. Par conséquent, si vos tests partagent un état d'application, la majorité de cet état partagé est supprimé du processeur ou de la mémoire de votre appareil après chaque test. Pour supprimer tous les états partagés du processeur et de la mémoire de votre appareil après chaque utilisez l'option clearPackageData. Consultez la section Activer depuis Gradle. pour obtenir un exemple.
• Les plantages sont isolés:même si un test plante, seul son propre instance de Instrumentation. Cela signifie que les autres tests votre suite continuent de s'exécuter et fournissent des résultats de test complets.

Cette isolation peut entraîner une augmentation de la durée d'exécution du test, car Android Test Orchestrator redémarre l'application après chaque test.

Remarque :L'exécuteur d'instrumentation de test obsolète, InstrumentationTestRunner, n'est pas compatible avec Android Test Orchestrator. Si vous utilisez InstrumentationTestRunner, vous devrez peut-être utiliser une autre instrumentation pour utiliser l'orchestration sur l'appareil.

Android Studio et Firebase Test Lab disposent tous deux d'Android Test Orchestrator préinstallé, mais vous devez l'activer dans Android Google Marketing Platform Studio.

Activer depuis Gradle

Pour activer Android Test Orchestrator à l'aide de l'outil de ligne de commande Gradle, procédez comme suit : procédez comme suit:

• Étape 1: Modifiez le fichier Gradle. Ajoutez les déclarations suivantes à votre le fichier build.gradle du projet:

android {
 defaultConfig {
  ...
  testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"

  // The following argument makes the Android Test Orchestrator run its
  // "pm clear" command after each test invocation. This command ensures
  // that the app's state is completely cleared between tests.
  testInstrumentationRunnerArguments clearPackageData: 'true'
 }

 testOptions {
  execution 'ANDROIDX_TEST_ORCHESTRATOR'
 }
}

dependencies {
 androidTestImplementation 'androidx.test:runner:1.1.0'
 androidTestUtil 'androidx.test:orchestrator:1.1.0'
}

• Étape 2: Exécutez Android Test Orchestrator à l'aide de la commande suivante:

./gradlew connectedCheck

Activer depuis Android Studio

Pour activer Android Test Orchestrator dans Android Studio, ajoutez les instructions affichées dans Activer depuis Gradle vers le fichier build.gradle de votre application.

Activer à partir de la ligne de commande

Pour utiliser Android Test Orchestrator sur la ligne de commande, exécutez les commandes suivantes : dans une fenêtre de terminal:

DEVICE_API_LEVEL=$(adb shell getprop ro.build.version.sdk)

FORCE_QUERYABLE_OPTION=""
if [[ $DEVICE_API_LEVEL -ge 30 ]]; then
   FORCE_QUERYABLE_OPTION="--force-queryable"
fi

# uninstall old versions
adb uninstall androidx.test.services
adb uninstall androidx.test.orchestrator

# Install the test orchestrator.
adb install $FORCE_QUERYABLE_OPTION -r path/to/m2repository/androidx/test/orchestrator/1.4.2/orchestrator-1.4.2.apk

# Install test services.
adb install $FORCE_QUERYABLE_OPTION -r path/to/m2repository/androidx/test/services/test-services/1.4.2/test-services-1.4.2.apk

# Replace "com.example.test" with the name of the package containing your tests.
# Add "-e clearPackageData true" to clear your app's data in between runs.
adb shell 'CLASSPATH=$(pm path androidx.test.services) app_process / \
 androidx.test.services.shellexecutor.ShellMain am instrument -w -e \
 targetInstrumentation com.example.test/androidx.test.runner.AndroidJUnitRunner \
 androidx.test.orchestrator/.AndroidTestOrchestrator'

Comme le montre la syntaxe de la commande, vous devez installer Android Test Orchestrator, puis l'utiliser directement.

Remarque :Si vous ne connaissez pas l'instrumentation cible, vous pouvez la rechercher en exécutant la commande suivante:

adb shell pm list instrumentation

Utiliser différentes chaînes d'outils

Si vous utilisez une autre chaîne d'outils pour tester votre application, vous pouvez toujours utiliser Android Pour tester Orchestrator, procédez comme suit:

1. Incluez les packages nécessaires dans le fichier de compilation de votre application.
2. Activez Android Test Orchestrator à partir de la ligne de commande.

Architecture

L'APK du service Orchestrator est stocké dans un processus distinct de APK de test et l'APK de l'application testée:

<ph type="x-smartling-placeholder">

</ph>

Figure 1: Structure du fichier APK d'orchestration de tests Android

Android Test Orchestrator collecte les tests JUnit au début de votre test mais il exécute ensuite chaque test séparément, dans sa propre instance de Instrumentation

Plus d'informations

Pour en savoir plus sur l'utilisation d'AndroidJUnitRunner, consultez la documentation de référence de l'API.

Ressources supplémentaires

Pour en savoir plus sur l'utilisation de AndroidJUnitRunner, consultez les ressources.

Exemples

• AndroidJunitRunnerSample: présente les annotations de test, les tests paramétrés et la création d'une suite de tests.