Bibliotheken und Tools zum Testen verschiedener Bildschirmgrößen

Android bietet eine Vielzahl von Tools und APIs, mit denen Sie Tests für unterschiedliche Bildschirm- und Fenstergrößen erstellen können.

DeviceConfigurationOverride

Mit dem Composeable DeviceConfigurationOverride können Sie Konfigurationsattribute überschreiben, um mehrere Bildschirm- und Fenstergrößen in Compose-Layouts zu testen. Die ForcedSize-Überschreibung passt jedes Layout in den verfügbaren Bereich ein. So können Sie UI-Tests auf jeder Bildschirmgröße ausführen. Sie können beispielsweise ein kleines Smartphone verwenden, um alle UI-Tests auszuführen, einschließlich UI-Tests für große Smartphones, faltbare Geräte und Tablets.

   DeviceConfigurationOverride(
        DeviceConfigurationOverride.ForcedSize(DpSize(1280.dp, 800.dp))
    ) {
        MyScreen() // Will be rendered in the space for 1280dp by 800dp without clipping.
    }
Abbildung 1: Mit DeviceConfigurationOverride ein Tablet-Layout auf ein Gerät mit kleinerem Formfaktor anpassen, z. B. bei \*Jetzt bei Android*.

Außerdem können Sie mit diesem Composeable Schriftgröße, Themen und andere Eigenschaften festlegen, die Sie in verschiedenen Fenstergrößen testen möchten.

Robolectric

Mit Robolectric können Sie Compose- oder ansichtenbasierte UI-Tests lokal auf der JVM ausführen – ohne Geräte oder Emulatoren. Sie können Robolectric konfigurieren, um unter anderem bestimmte Bildschirmgrößen zu verwenden.

Im folgenden Beispiel aus Now in Android ist Robolectric so konfiguriert, dass eine Bildschirmgröße von 1.000 x 1.000 dp mit einer Auflösung von 480 dpi emuliert wird:

@RunWith(RobolectricTestRunner::class)
// Configure Robolectric to use a very large screen size that can fit all of the test sizes.
// This allows enough room to render the content under test without clipping or scaling.
@Config(qualifiers = "w1000dp-h1000dp-480dpi")
class NiaAppScreenSizesScreenshotTests { ... }

Sie können die Qualifikatoren auch im Testkörper festlegen, wie in diesem Snippet aus dem Beispiel Jetzt bei Android:

val (width, height, dpi) = ...

// Set qualifiers from specs.
RuntimeEnvironment.setQualifiers("w${width}dp-h${height}dp-${dpi}dpi")

Hinweis: Mit RuntimeEnvironment.setQualifiers() werden die System- und Anwendungsressourcen mit der neuen Konfiguration aktualisiert, es werden jedoch keine Aktionen für aktive Aktivitäten oder andere Komponenten ausgelöst.

Weitere Informationen finden Sie in der Dokumentation zur Gerätekonfiguration von Robolectric.

Von Gradle verwaltete Geräte

Mit dem Android Gradle-Plug-in Von Gradle verwaltete Geräte (GMD) können Sie die Spezifikationen der Emulatoren und echten Geräte definieren, auf denen Ihre instrumentierten Tests ausgeführt werden. Erstellen Sie Spezifikationen für Geräte mit unterschiedlichen Bildschirmgrößen, um eine Teststrategie zu implementieren, bei der bestimmte Tests auf bestimmten Bildschirmgrößen ausgeführt werden müssen. Wenn Sie GMD mit Continuous Integration (CI) verwenden, können Sie dafür sorgen, dass die entsprechenden Tests bei Bedarf ausgeführt werden. Außerdem können Sie Emulatoren bereitstellen und starten und Ihre CI-Einrichtung vereinfachen.

android {
    testOptions {
        managedDevices {
            devices {
                // Run with ./gradlew nexusOneApi30DebugAndroidTest.
                nexusOneApi30(com.android.build.api.dsl.ManagedVirtualDevice) {
                    device = "Nexus One"
                    apiLevel = 30
                    // Use the AOSP ATD image for better emulator performance
                    systemImageSource = "aosp-atd"
                }
                // Run with ./gradlew  foldApi34DebugAndroidTest.
                foldApi34(com.android.build.api.dsl.ManagedVirtualDevice) {
                    device = "Pixel Fold"
                    apiLevel = 34
                    systemImageSource = "aosp-atd"
                }
            }
        }
    }
}

Im Projekt testing-samples finden Sie mehrere Beispiele für GMD.

Firebase Test Lab

Verwenden Sie Firebase Test Lab (FTL) oder einen ähnlichen Device-Farm-Dienst, um Ihre Tests auf bestimmten echten Geräten auszuführen, auf die Sie möglicherweise keinen Zugriff haben, z. B. auf faltbare Geräte oder Tablets verschiedener Größen. Firebase Test Lab ist ein kostenpflichtiger Dienst mit einer kostenlosen Stufe. FTL unterstützt auch die Ausführung von Tests auf Emulatoren. Diese Dienste verbessern die Zuverlässigkeit und Geschwindigkeit der instrumentierten Tests, da Geräte und Emulatoren vorab bereitgestellt werden können.

Informationen zur Verwendung von FTL mit GMD finden Sie unter Tests mit Gradle verwalteten Geräten skalieren.

Filterung mit dem Test-Runner testen

Eine optimale Teststrategie sollte nicht zweimal dasselbe prüfen. Daher müssen die meisten UI-Tests nicht auf mehreren Geräten ausgeführt werden. Normalerweise filtern Sie Ihre UI-Tests, indem Sie alle oder die meisten davon auf einem Smartphone-Formfaktor und nur einen Teil auf Geräten mit unterschiedlichen Bildschirmgrößen ausführen.

Sie können bestimmte Tests annotieren, damit sie nur auf bestimmten Geräten ausgeführt werden, und dann dem AndroidJUnitRunner über den Befehl, mit dem die Tests ausgeführt werden, ein Argument übergeben.

Sie können beispielsweise verschiedene Anmerkungen erstellen:

annotation class TestExpandedWidth
annotation class TestCompactWidth

und für verschiedene Tests verwenden:

class MyTestClass {

    @Test
    @TestExpandedWidth
    fun myExample_worksOnTablet() {
        ...
    }

    @Test
    @TestCompactWidth
    fun myExample_worksOnPortraitPhone() {
        ...
    }

}

Sie können dann beim Ausführen der Tests die Eigenschaft android.testInstrumentationRunnerArguments.annotation verwenden, um bestimmte Tests herauszufiltern. Wenn Sie beispielsweise Gradle-verwaltete Geräte verwenden:

$ ./gradlew pixelTabletApi30DebugAndroidTest -Pandroid.testInstrumentationRunnerArguments.annotation='com.sample.TestExpandedWidth'

Wenn Sie GMD nicht verwenden und Emulatoren in der CI verwalten, prüfen Sie zuerst, ob der richtige Emulator oder das richtige Gerät bereit und verbunden ist, und übergeben Sie den Parameter dann an einen der Gradle-Befehle, um instrumentierte Tests auszuführen:

$ ./gradlew connectedAndroidTest -Pandroid.testInstrumentationRunnerArguments.annotation='com.sample.TestExpandedWidth'

Hinweis: Mit Espresso Device (siehe nächster Abschnitt) können Tests auch anhand von Geräteeigenschaften gefiltert werden.

Espressogerät

Verwenden Sie Espresso Device, um Aktionen auf Emulatoren in Tests auszuführen, bei denen beliebige Arten von instrumentierten Tests verwendet werden, einschließlich Espresso-, Compose- oder UI Automator-Tests. Dazu kann das Festlegen der Bildschirmgröße oder das Umschalten zwischen verschiedenen Zuständen oder Positionen des faltbaren Geräts gehören. Sie können beispielsweise einen faltbaren Emulator steuern und ihn in den Tablet-Modus versetzen. Espresso Device enthält außerdem JUnit-Regeln und Anmerkungen, um bestimmte Funktionen zu erzwingen:

@RunWith(AndroidJUnit4::class)
class OnDeviceTest {

    @get:Rule(order=1) val activityScenarioRule = activityScenarioRule<MainActivity>()

    @get:Rule(order=2) val screenOrientationRule: ScreenOrientationRule =
        ScreenOrientationRule(ScreenOrientation.PORTRAIT)

    @Test
    fun tabletopMode_playerIsDisplayed() {
        // Set the device to tabletop mode.
        onDevice().setTabletopMode()
        onView(withId(R.id.player)).check(matches(isDisplayed()))
    }
}

Hinweis: Espresso Device befindet sich noch in der Alphaphase und unterliegt den folgenden Anforderungen:

  • Android Gradle Plugin 8.3 oder höher
  • Android-Emulator 33.1.10 oder höher
  • Ein virtuelles Android-Gerät mit API-Level 24 oder höher

Tests filtern

Espresso Device kann die Eigenschaften verbundener Geräte lesen, damit Sie Tests mithilfe von Anmerkungen filtern können. Wenn die annotierten Anforderungen nicht erfüllt sind, werden die Tests übersprungen.

Anmerkung „RequiresDeviceMode“

Die Anmerkung RequiresDeviceMode kann mehrmals verwendet werden, um einen Test anzugeben, der nur ausgeführt wird, wenn alle DeviceMode-Werte auf dem Gerät unterstützt werden.

class OnDeviceTest {
    ...
    @Test
    @RequiresDeviceMode(TABLETOP)
    @RequiresDeviceMode(BOOK)
    fun tabletopMode_playerIdDisplayed() {
        // Set the device to tabletop mode.
        onDevice().setTabletopMode()
        onView(withId(R.id.player)).check(matches(isDisplayed()))
    }
}

RequiresDisplay-Anmerkung

Mit der Anmerkung RequiresDisplay können Sie die Breite und Höhe des Gerätebildschirms mithilfe von Größenklassen angeben. Diese definieren Dimensions-Buckets gemäß den offiziellen Fenstergrößenklassen.

class OnDeviceTest {
    ...
    @Test
    @RequiresDisplay(EXPANDED, COMPACT)
    fun myScreen_expandedWidthCompactHeight() {
        ...
    }
}

Größe von Displays ändern

Verwenden Sie die Methode setDisplaySize(), um die Größe des Bildschirms zur Laufzeit anzupassen. Verwenden Sie die Methode in Verbindung mit der Klasse DisplaySizeRule. Dadurch werden alle während der Tests vorgenommenen Änderungen vor dem nächsten Test rückgängig gemacht.

@RunWith(AndroidJUnit4::class)
class ResizeDisplayTest {

    @get:Rule(order = 1) val activityScenarioRule = activityScenarioRule<MainActivity>()

    // Test rule for restoring device to its starting display size when a test case finishes.
    @get:Rule(order = 2) val displaySizeRule: DisplaySizeRule = DisplaySizeRule()

    @Test
    fun resizeWindow_compact() {
        onDevice().setDisplaySize(
            widthSizeClass = WidthSizeClass.COMPACT,
            heightSizeClass = HeightSizeClass.COMPACT
        )
        // Verify visual attributes or state restoration.
    }
}

Wenn Sie die Größe eines Displays mit setDisplaySize() ändern, hat das keine Auswirkungen auf die Dichte des Geräts. Wenn eine Dimension also nicht auf das Zielgerät passt, schlägt der Test mit UnsupportedDeviceOperationException fehl. Wenn Sie verhindern möchten, dass in diesem Fall Tests ausgeführt werden, filtern Sie sie mithilfe der Anmerkung RequiresDisplay heraus:

@RunWith(AndroidJUnit4::class)
class ResizeDisplayTest {

    @get:Rule(order = 1) var activityScenarioRule = activityScenarioRule<MainActivity>()

    // Test rule for restoring device to its starting display size when a test case finishes.
    @get:Rule(order = 2) var displaySizeRule: DisplaySizeRule = DisplaySizeRule()

    /**
     * Setting the display size to EXPANDED would fail in small devices, so the [RequiresDisplay]
     * annotation prevents this test from being run on devices outside the EXPANDED buckets.
     */
    @RequiresDisplay(
        widthSizeClass = WidthSizeClassEnum.EXPANDED,
        heightSizeClass = HeightSizeClassEnum.EXPANDED
    )
    @Test
    fun resizeWindow_expanded() {
        onDevice().setDisplaySize(
            widthSizeClass = WidthSizeClass.EXPANDED,
            heightSizeClass = HeightSizeClass.EXPANDED
        )
        // Verify visual attributes or state restoration.
    }
}

StateRestorationTester

Mit der Klasse StateRestorationTester wird die Wiederherstellung des Zustands für zusammensetzbare Komponenten getestet, ohne Aktivitäten neu zu erstellen. Dadurch werden Tests schneller und zuverlässiger, da die Wiederherstellung von Aktivitäten ein komplexer Prozess mit mehreren Synchronisierungsmechanismen ist:

@Test
fun compactDevice_selectedEmailEmailRetained_afterConfigChange() {
    val stateRestorationTester = StateRestorationTester(composeTestRule)

    // Set content through the StateRestorationTester object.
    stateRestorationTester.setContent {
        MyApp()
    }

    // Simulate a config change.
    stateRestorationTester.emulateSavedInstanceStateRestore()
}

Bibliothek für Window-Tests

Die Window Testing Library enthält Dienstprogramme, mit denen Sie Tests schreiben können, die auf Funktionen zur Fensterverwaltung basieren oder diese überprüfen, z. B. Eingebettete Aktivitäten oder faltbare Funktionen. Das Artefakt ist über das Maven-Repository von Google verfügbar.

Mit der Funktion FoldingFeature() können Sie beispielsweise einen benutzerdefinierten FoldingFeature generieren, den Sie in der Vorschau von „Compose“ verwenden können. Verwenden Sie in Java die Funktion createFoldingFeature().

In einer Compose-Vorschau können Sie FoldingFeature so implementieren:

@Preview(showBackground = true, widthDp = 480, heightDp = 480)
@Composable private fun FoldablePreview() =
    MyApplicationTheme {
        ExampleScreen(
            displayFeatures = listOf(FoldingFeature(Rect(0, 240, 480, 240)))
        )
 }

Außerdem können Sie mit der Funktion TestWindowLayoutInfo() Displayfunktionen in UI-Tests emulieren. Im folgenden Beispiel wird ein FoldingFeature mit einem vertikalen Scharnier HALF_OPENED in der Mitte des Displays simuliert und dann geprüft, ob das Layout wie erwartet ist:

Schreiben

import androidx.window.layout.FoldingFeature.Orientation.Companion.VERTICAL
import androidx.window.layout.FoldingFeature.State.Companion.HALF_OPENED
import androidx.window.testing.layout.FoldingFeature
import androidx.window.testing.layout.TestWindowLayoutInfo
import androidx.window.testing.layout.WindowLayoutInfoPublisherRule

@RunWith(AndroidJUnit4::class)
class MediaControlsFoldingFeatureTest {

    @get:Rule(order=1)
    val composeTestRule = createAndroidComposeRule<ComponentActivity>()

    @get:Rule(order=2)
    val windowLayoutInfoPublisherRule = WindowLayoutInfoPublisherRule()

    @Test
    fun foldedWithHinge_foldableUiDisplayed() {
        composeTestRule.setContent {
            MediaPlayerScreen()
        }

        val hinge = FoldingFeature(
            activity = composeTestRule.activity,
            state = HALF_OPENED,
            orientation = VERTICAL,
            size = 2
        )

        val expected = TestWindowLayoutInfo(listOf(hinge))
        windowLayoutInfoPublisherRule.overrideWindowLayoutInfo(expected)

        composeTestRule.waitForIdle()

        // Verify that the folding feature is detected and media controls shown.
        composeTestRule.onNodeWithTag("MEDIA_CONTROLS").assertExists()
    }
}

Aufrufe

import androidx.window.layout.FoldingFeature.Orientation
import androidx.window.layout.FoldingFeature.State
import androidx.window.testing.layout.FoldingFeature
import androidx.window.testing.layout.TestWindowLayoutInfo
import androidx.window.testing.layout.WindowLayoutInfoPublisherRule

@RunWith(AndroidJUnit4::class)
class MediaControlsFoldingFeatureTest {

    @get:Rule(order=1)
    val activityRule = ActivityScenarioRule(MediaPlayerActivity::class.java)

    @get:Rule(order=2)
    val windowLayoutInfoPublisherRule = WindowLayoutInfoPublisherRule()

    @Test
    fun foldedWithHinge_foldableUiDisplayed() {
        activityRule.scenario.onActivity { activity ->
            val feature = FoldingFeature(
                activity = activity,
                state = State.HALF_OPENED,
                orientation = Orientation.VERTICAL)
            val expected = TestWindowLayoutInfo(listOf(feature))
            windowLayoutInfoPublisherRule.overrideWindowLayoutInfo(expected)
        }

        // Verify that the folding feature is detected and media controls shown.
        onView(withId(R.id.media_controls)).check(matches(isDisplayed()))
    }
}

Weitere Beispiele finden Sie im WindowManager-Projekt.

Weitere Informationen

Dokumentation

Produktproben

Codelabs