Instrumentierte Tests erstellen

Instrumentierte Tests werden auf physikalischen oder emulierten Android-Geräten ausgeführt. So können sie die Android-Framework-APIs nutzen. Instrumentierte Tests bieten daher eine höhere Genauigkeit als lokale Tests, sie werden jedoch viel langsamer ausgeführt.

Wir empfehlen, instrumentierte Tests nur dann zu verwenden, wenn Sie das Verhalten eines echten Geräts testen müssen. AndroidX Test bietet mehrere Bibliotheken, mit denen sich bei Bedarf instrumentierte Tests einfacher schreiben lassen.

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 Sie ein neues Projekt erstellen, und enthält einen instrumentierten Beispieltest.

Bevor Sie beginnen, sollten Sie AndroidX Test APIs hinzufügen, mit denen Sie schnell instrumentierten Testcode für Ihre Apps erstellen und ausführen können. AndroidX Test umfasst einen 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 so konfigurieren, dass der Test-Runner und die von AndroidX Test bereitgestellten Regel-APIs verwendet werden.

In der Datei build.gradle der obersten Ebene Ihrer App müssen Sie diese Bibliotheken als Abhängigkeiten angeben:

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"
}

Die aktuellen Versionen finden Sie in den Versionshinweisen für AndroidX und den Versionshinweisen zur Composer-UI.

Wenn Sie JUnit 4-Testklassen verwenden und Zugriff auf Funktionen wie Testfilter haben möchten, müssen Sie AndroidJUnitRunner als Standard-Runner für die Testinstrumentierung in Ihrem Projekt angeben. Dazu nehmen Sie die folgende Einstellung in die Datei build.gradle Ihrer App auf Modulebene auf:

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

Instrumentierte Testklasse erstellen

Die instrumentierte Testklasse sollte eine JUnit 4-Testklasse sein, die der im Abschnitt Lokale Tests erstellen beschriebenen Klasse ähnelt.

Geben Sie zum Erstellen einer instrumentierten JUnit 4-Testklasse AndroidJUnit4 als Standard-Test-Runner an.

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

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. Im Leitfaden zu Android Studio erfahren Sie, wie Sie

Weitere Informationen

UI-Tests sind in der Regel instrumentierte Tests, mit denen das korrekte Verhalten der UI überprüft wird. Sie verwenden Frameworks wie Espresso oder Compose Test. Weitere Informationen finden Sie im Leitfaden für UI-Tests.

Weitere Informationen zur Verwendung von Instrumentierungstests finden Sie in den folgenden Ressourcen.

Beispiel

Codelabs