Instrumentierte Tests erstellen

Instrumentierte Tests werden auf physikalischen oder emulierten Android-Geräten ausgeführt. Als können sie die Android-Framework-APIs nutzen. Instrumentierte Tests bieten daher eine höhere Genauigkeit als lokale Tests, obwohl sie wesentlich häufiger ausgeführt werden. langsam.

Wir empfehlen, instrumentierte Tests nur dann zu verwenden, wenn Sie wie ein echtes Gerät funktioniert. AndroidX Test bietet mehrere Bibliotheken. die es einfacher machen, bei Bedarf instrumentierte Tests zu schreiben.

Testumgebung einrichten

In Ihrem Android Studio-Projekt speichern Sie die Quelldateien für instrumentierte Tests in module-name/src/androidTest/java/. Dieses Verzeichnis ist bereits vorhanden, wenn erstellen Sie ein neues Projekt und enthält ein Beispiel für einen instrumentierten Test.

Bevor Sie beginnen, sollten Sie AndroidX Test APIs hinzufügen, mit denen Sie schnell instrumentierten Testcode für Ihre Apps erstellen und ausführen. Der AndroidX-Test beinhaltet ein JUnit 4-Test-Runner, AndroidJUnitRunner und APIs für funktionale UI-Tests wie Espresso, UI Automator und Compose Test.

Außerdem müssen Sie die Android-Testabhängigkeiten für Ihr Projekt konfigurieren, um Test-Runner und die Regel-APIs verwenden, die von AndroidX Test bereitgestellt werden

Diese Bibliotheken musst du in der Datei build.gradle der obersten Ebene deiner App angeben als Abhängigkeiten:

dependencies {
    androidTestImplementation "androidx.test:runner:$androidXTestVersion"
    androidTestImplementation "androidx.test:rules:$androidXTestVersion"
    // Optional -- UI testing with Espresso
    androidTestImplementation "androidx.test.espresso:espresso-core:$espressoVersion"
    // Optional -- UI testing with UI Automator
    androidTestImplementation "androidx.test.uiautomator:uiautomator:$uiAutomatorVersion"
    // Optional -- UI testing with Compose
    androidTestImplementation "androidx.compose.ui:ui-test-junit4:$compose_version"
}

Sie finden die aktuellen Versionen in den Versionshinweisen für AndroidX und im Editor Versionshinweise zur Benutzeroberfläche

Um JUnit 4-Testklassen zu verwenden und Zugriff auf Funktionen wie die Testfilterung zu haben, Geben Sie AndroidJUnitRunner als Standard-Testinstrumentierung an. in Ihrem Projekt ausführen, indem Sie die folgende Einstellung im build.gradle-Datei auf Modulebene:

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

Instrumentierte Testklasse erstellen

Ihre instrumentierte Testklasse sollte eine JUnit 4-Testklasse sein, die der Die Klasse, die im Abschnitt zum Erstellen lokaler Tests beschrieben wurde

Um eine instrumentierte JUnit 4-Testklasse zu erstellen, gib AndroidJUnit4 als deinen Standard-Test-Runner.

Das folgende Beispiel zeigt, wie Sie einen instrumentierten Test schreiben, um zu prüfen, die Schnittstelle Parcelable für den LogHistory Klasse:

Kotlin

import android.os.Parcel
import android.text.TextUtils.writeToParcel
import androidx.test.filters.SmallTest
import androidx.test.runner.AndroidJUnit4
import com.google.common.truth.Truth.assertThat
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith

const val TEST_STRING = "This is a string"
const val TEST_LONG = 12345678L

// @RunWith is required only if you use a mix of JUnit3 and JUnit4.
@RunWith(AndroidJUnit4::class)
@SmallTest
class LogHistoryAndroidUnitTest {
    private lateinit var logHistory: LogHistory

    @Before
    fun createLogHistory() {
        logHistory = LogHistory()
    }

    @Test
    fun logHistory_ParcelableWriteRead() {
        val parcel = Parcel.obtain()
        logHistory.apply {
            // Set up the Parcelable object to send and receive.
            addEntry(TEST_STRING, TEST_LONG)

            // Write the data.
            writeToParcel(parcel, describeContents())
        }

        // After you're done with writing, you need to reset the parcel for reading.
        parcel.setDataPosition(0)

        // Read the data.
        val createdFromParcel: LogHistory = LogHistory.CREATOR.createFromParcel(parcel)
        createdFromParcel.getData().also { createdFromParcelData: List<Pair<String, Long>> ->

            // Verify that the received data is correct.
            assertThat(createdFromParcelData.size).isEqualTo(1)
            assertThat(createdFromParcelData[0].first).isEqualTo(TEST_STRING)
            assertThat(createdFromParcelData[0].second).isEqualTo(TEST_LONG)
        }
    }
}

Java

import android.os.Parcel;
import android.util.Pair;
import androidx.test.runner.AndroidJUnit4;
import com.google.common.truth.Truth.assertThat;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

// @RunWith is required only if you use a mix of JUnit3 and JUnit4.
@RunWith(AndroidJUnit4.class)
public class LogHistoryAndroidUnitTest {

    public static final String TEST_STRING = "This is a string";
    public static final long TEST_LONG = 12345678L;
    private LogHistory mLogHistory;

    @Before
    public void createLogHistory() {
        mLogHistory = new LogHistory();
    }

    @Test
    public void logHistory_ParcelableWriteRead() {
        // Set up the Parcelable object to send and receive.
        mLogHistory.addEntry(TEST_STRING, TEST_LONG);

        // Write the data.
        Parcel parcel = Parcel.obtain();
        mLogHistory.writeToParcel(parcel, mLogHistory.describeContents());

        // After you're done with writing, you need to reset the parcel for reading.
        parcel.setDataPosition(0);

        // Read the data.
        LogHistory createdFromParcel = LogHistory.CREATOR.createFromParcel(parcel);
        List<Pair<String, Long>> createdFromParcelData
                = createdFromParcel.getData();

        // Verify that the received data is correct.
        assertThat(createdFromParcelData.size()).isEqualTo(1);
        assertThat(createdFromParcelData.get(0).first).isEqualTo(TEST_STRING);
        assertThat(createdFromParcelData.get(0).second).isEqaulTo(TEST_LONG);
    }
}

Instrumentierte Tests ausführen

Instrumentierte Tests können auf echten Geräten oder Emulatoren ausgeführt werden. In der Android-App In der Anleitung zu Studio erhalten Sie Informationen zu folgenden Themen:

Weitere Informationen

UI-Tests sind in der Regel instrumentierte Tests, die das korrekte Verhalten eines auf der Benutzeroberfläche. Dafür werden Frameworks wie Espresso oder Compose Test verwendet. Weitere Informationen finden Sie im Leitfaden zum Testen der Benutzeroberfläche.

Weitere Informationen zur Verwendung von Instrumentierungstests finden Sie hier: Ressourcen.

Beispiel

Codelabs