Automatisierte Tests mit UI Automator schreiben

UI Automator ist ein UI-Test-Framework, das sich für appübergreifende Funktionen eignet. System- und installierten Apps testen. Über die UI Automator APIs können Sie mit sichtbaren Elementen auf einem Gerät, unabhängig davon, in welchem Activity sich befindet damit Sie bestimmte Aktionen ausführen können, z. B. das Menü „Einstellungen“ oder den App Launcher auf einem Testgerät. Ihr Test kann eine UI-Komponente suchen, indem Sie mit passenden Beschreibungen wie dem in der Komponente angezeigten Text oder Inhaltsbeschreibung.

Das Test-Framework „UI Automator“ ist eine instrumentierungsbasierte API und funktioniert mit dem Test-Runner AndroidJUnitRunner. Sie eignet sich gut zum Schreiben Automatisierte Tests im opaken Feldstil, bei denen der Testcode nicht auf internen Implementierungsdetails der Ziel-App.

Zu den Hauptfunktionen des UI Automator-Test-Frameworks gehören:

Auf Gerätestatus zugreifen

Das Test-Framework „UI Automator“ bietet eine UiDevice-Klasse für den Zugriff und Vorgänge auf dem Gerät ausführen, auf dem die Ziel-App ausgeführt wird. Sie können rufen Sie seine Methoden auf, um auf Geräteeigenschaften wie die aktuelle Ausrichtung oder Anzeigegröße. Mit der Klasse UiDevice können Sie außerdem Folgendes ausführen: Aktionen:

  1. Ändern Sie die Gerätedrehung.
  2. Drücken Sie Hardwaretasten, z. B. „Lauter“.
  3. Drücken Sie die Zurück-, Home- oder Menütaste.
  4. Öffnen Sie die Benachrichtigungsleiste.
  5. Machen Sie einen Screenshot des aktuellen Fensters.

Wenn du beispielsweise das Drücken der Startbildschirmtaste simulieren möchtest, rufe UiDevice.pressHome() auf. .

APIs für Benutzeroberflächenautomatisierung

Mit den UI Automator APIs können Sie robuste Tests schreiben, ohne Implementierungsdetails der App, auf die Sie Ihre App ausrichten. Sie können APIs, um UI-Komponenten über mehrere Apps hinweg zu erfassen und zu bearbeiten:

  • UiObject2: Steht für ein UI-Element, das auf dem Gerät sichtbar ist.
  • BySelector: Gibt Kriterien für übereinstimmende UI-Elemente an.
  • By: Erstellt BySelector kurz und prägnant.
  • Configurator: Hiermit können Sie wichtige Parameter zum Ausführen von Tests mit UI-Automator festlegen.

Der folgende Code zeigt beispielsweise, wie Sie ein Testskript schreiben können, eine Gmail-App auf dem Gerät öffnet:

Kotlin


device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
device.pressHome()

val gmail: UiObject2 = device.findObject(By.text("Gmail"))
// Perform a click and wait until the app is opened.
val opened: Boolean = gmail.clickAndWait(Until.newWindow(), 3000)
assertThat(opened).isTrue()

Java


device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
device.pressHome();

UiObject2 gmail = device.findObject(By.text("Gmail"));
// Perform a click and wait until the app is opened.
Boolean opened = gmail.clickAndWait(Until.newWindow(), 3000);
assertTrue(opened);

UI Automator einrichten

Bevor Sie den UI-Test mit UI Automator erstellen, müssen Sie den Test konfigurieren Speicherort des Quellcodes und Projektabhängigkeiten, wie unter Projekt einrichten für AndroidX Test.

In der Datei build.gradle des Android-App-Moduls musst du eine Abhängigkeit festlegen Referenz zur UI Automator-Bibliothek:

Kotlin

dependencies {
  ...
  androidTestImplementation('androidx.test.uiautomator:uiautomator:2.3.0-alpha03')
}

Cool

dependencies {
  ...
  androidTestImplementation 'androidx.test.uiautomator:uiautomator:2.3.0-alpha03'
}

Um die Tests mit dem UI-Automator zu optimieren, sollten Sie zuerst die UI-Komponenten und stellen Sie sicher, dass auf sie zugegriffen werden kann. Diese Optimierungstipps sind die in den nächsten beiden Abschnitten beschrieben werden.

Benutzeroberfläche auf einem Gerät prüfen

Bevor Sie den Test entwerfen, sehen Sie sich die UI-Komponenten an, die auf der . Um sicherzustellen, dass Ihre UI-Automator-Tests auf diese Komponenten zugreifen können, ob diese Komponenten sichtbare Beschriftungen haben, android:contentDescription-Werte oder beides.

Das uiautomatorviewer-Tool bietet eine bequeme visuelle Oberfläche für die Prüfung Layout-Hierarchie und die Eigenschaften sichtbarer UI-Komponenten im Vordergrund des Geräts angezeigt. Mit diesen Informationen können Sie detaillierte Tests mit UI Automator durchführen. Sie können beispielsweise einen UI-Selektor erstellen die mit einer bestimmten sichtbaren Property übereinstimmt.

So starten Sie das uiautomatorviewer-Tool:

  1. Starte die Ziel-App auf einem physischen Gerät.
  2. Verbinden Sie das Gerät mit dem Entwicklungscomputer.
  3. Öffnen Sie ein Terminalfenster und wechseln Sie zum Verzeichnis <android-sdk>/tools/.
  4. Führen Sie das Tool mit dem folgenden Befehl aus:
 $ uiautomatorviewer

So zeigen Sie die UI-Eigenschaften für Ihre Anwendung an:

  1. Klicken Sie in der uiautomatorviewer-Oberfläche auf die Schaltfläche Geräte-Screenshot.
  2. Bewegen Sie den Mauszeiger im linken Bereich auf den Snapshot, um die UI-Komponenten zu sehen. uiautomatorviewer-Tool identifiziert wird. Die Eigenschaften sind in der niedriger rechten Steuerfeld und die Layouthierarchie im rechten oberen Bereich.
  3. Klicken Sie optional auf die Schaltfläche NAF-Knoten umschalten, um die UI-Komponenten aufzurufen. die für UI Automator nicht zugänglich sind. Nur begrenzte Informationen können die für diese Komponenten zur Verfügung stehen.

Weitere Informationen zu gängigen UI-Komponenten, die von Android bereitgestellt werden, finden Sie unter Nutzer Schnittstelle.

Achten Sie darauf, dass Ihre Aktivität barrierefrei ist

Das Test-Framework UI Automator funktioniert besser bei Apps, die Android-Bedienungshilfen Wenn Sie UI-Elemente vom Typ View oder eine abgeleitete Klasse von View aus dem SDK ist, müssen Sie die Barrierefreiheit nicht implementieren da diese Kurse das bereits für Sie erledigt haben.

Einige Apps verwenden jedoch benutzerdefinierte UI-Elemente, um die Nutzererfahrung zu verbessern. Solche Elemente bieten keine automatische Unterstützung für Bedienungshilfen. Wenn Ihre App Instanzen einer abgeleiteten Klasse von View enthält, die nicht aus dem SDK stammt, fügen Sie diesen Elementen Bedienungshilfen hinzu, indem Sie die folgenden Schritten:

  1. Erstellen Sie eine konkrete Klasse, die ExploreByTouchHelper erweitert.
  2. Verknüpfen Sie eine Instanz Ihrer neuen Klasse mit einem bestimmten benutzerdefinierten UI-Element durch setAccessibilityDelegate() aufruft.

Weitere Informationen zum Hinzufügen von Bedienungshilfen zu benutzerdefinierten Ansichten finden Sie unter Barrierefreie benutzerdefinierte Ansichten erstellen. Weitere Informationen über Allgemeine Best Practices für Bedienungshilfen unter Android finden Sie unter Apps optimieren Barrierefrei:

UI Automator-Testklasse erstellen

Ihre UI Automator-Testklasse sollte genauso geschrieben sein wie ein JUnit 4-Test. . Weitere Informationen zum Erstellen von JUnit 4-Testklassen und zur Verwendung von JUnit 4 Assertions und Annotationen finden Sie unter Testklasse für instrumentierte Einheiten erstellen.

Fügen Sie zu Beginn des Tests die Annotation @RunWith(AndroidJUnit4.class) hinzu Klassendefinition. Außerdem müssen Sie die Klasse AndroidJUnitRunner angeben. in AndroidX Test als Standard-Test-Runner zur Verfügung gestellt. Dieser Schritt wird beschrieben Tests für UI Automator auf einem Gerät oder Emulator ausführen.

Implementieren Sie das folgende Programmiermodell in Ihrer UI Automator-Testklasse:

  1. Rufen Sie ein UiDevice-Objekt für den Zugriff auf das zu testende Gerät ab. Rufen Sie dazu die Methode getInstance() und übergeben Sie ein Instrumentation-Objekt als das Argument.
  2. Rufen Sie ein UiObject2-Objekt ab, um auf eine UI-Komponente zuzugreifen, die im (z. B. die aktuelle Ansicht im Vordergrund) durch Aufrufen des findObject() aufrufen.
  3. Simulieren Sie eine bestimmte Nutzerinteraktion für diese UI-Komponente, indem Sie UiObject2-Methode aufrufen Rufen Sie beispielsweise scrollUntil() zum Scrollen und setText() zum Bearbeiten eines Textfeldes. Sie können die APIs in den Schritten 2 und 3 aufrufen. und so oft wie nötig wiederholt, um komplexere Nutzungsinteraktionen zu testen, UI-Komponenten oder -abfolgen von Nutzeraktionen.
  4. Prüfen Sie, ob die Benutzeroberfläche den erwarteten Zustand oder das erwartete Verhalten widerspiegelt, nachdem diese Nutzer durchgeführt werden.

Diese Schritte werden in den folgenden Abschnitten ausführlicher beschrieben.

Auf UI-Komponenten zugreifen

Über das Objekt UiDevice können Sie primär auf das Objekt Status des Geräts. In Ihren Tests können Sie UiDevice-Methoden aufrufen, um zu prüfen, den Status verschiedener Eigenschaften wie die aktuelle Ausrichtung oder Anzeigegröße. Der Test kann das UiDevice-Objekt verwenden, um Aktionen auf Geräteebene auszuführen. z. B. das Erzwingen des Geräts in eine bestimmte Drehung, das Drücken des Steuerkreuzes und die Start- und die Menütaste drücken.

Es empfiehlt sich, den Test auf dem Startbildschirm des Geräts zu starten. Von auf dem Startbildschirm (oder an einer anderen auf dem Gerät ausgewählten Startposition) können Sie die von der UI Automator API bereitgestellten Methoden aufrufen, mit spezifischen UI-Elementen.

Das folgende Code-Snippet zeigt, wie Ihr Test eine Instanz von UiDevice und simulieren das Drücken der Startbildschirmtaste:

Kotlin


import org.junit.Before
import androidx.test.runner.AndroidJUnit4
import androidx.test.uiautomator.UiDevice
import androidx.test.uiautomator.By
import androidx.test.uiautomator.Until
...

private const val BASIC_SAMPLE_PACKAGE = "com.example.android.testing.uiautomator.BasicSample"
private const val LAUNCH_TIMEOUT = 5000L
private const val STRING_TO_BE_TYPED = "UiAutomator"

@RunWith(AndroidJUnit4::class)
@SdkSuppress(minSdkVersion = 18)
class ChangeTextBehaviorTest2 {

private lateinit var device: UiDevice

@Before
fun startMainActivityFromHomeScreen() {
  // Initialize UiDevice instance
  device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())

  // Start from the home screen
  device.pressHome()

  // Wait for launcher
  val launcherPackage: String = device.launcherPackageName
  assertThat(launcherPackage, notNullValue())
  device.wait(
    Until.hasObject(By.pkg(launcherPackage).depth(0)),
    LAUNCH_TIMEOUT
  )

  // Launch the app
  val context = ApplicationProvider.getApplicationContext<Context>()
  val intent = context.packageManager.getLaunchIntentForPackage(
  BASIC_SAMPLE_PACKAGE).apply {
    // Clear out any previous instances
    addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
  }
  context.startActivity(intent)

  // Wait for the app to appear
  device.wait(
    Until.hasObject(By.pkg(BASIC_SAMPLE_PACKAGE).depth(0)),
    LAUNCH_TIMEOUT
    )
  }
}

Java


import org.junit.Before;
import androidx.test.runner.AndroidJUnit4;
import androidx.test.uiautomator.UiDevice;
import androidx.test.uiautomator.By;
import androidx.test.uiautomator.Until;
...

@RunWith(AndroidJUnit4.class)
@SdkSuppress(minSdkVersion = 18)
public class ChangeTextBehaviorTest {

  private static final String BASIC_SAMPLE_PACKAGE
  = "com.example.android.testing.uiautomator.BasicSample";
  private static final int LAUNCH_TIMEOUT = 5000;
  private static final String STRING_TO_BE_TYPED = "UiAutomator";
  private UiDevice device;

  @Before
  public void startMainActivityFromHomeScreen() {
    // Initialize UiDevice instance
    device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());

    // Start from the home screen
    device.pressHome();

    // Wait for launcher
    final String launcherPackage = device.getLauncherPackageName();
    assertThat(launcherPackage, notNullValue());
    device.wait(Until.hasObject(By.pkg(launcherPackage).depth(0)),
    LAUNCH_TIMEOUT);

    // Launch the app
    Context context = ApplicationProvider.getApplicationContext();
    final Intent intent = context.getPackageManager()
    .getLaunchIntentForPackage(BASIC_SAMPLE_PACKAGE);
    // Clear out any previous instances
    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
    context.startActivity(intent);

    // Wait for the app to appear
    device.wait(Until.hasObject(By.pkg(BASIC_SAMPLE_PACKAGE).depth(0)),
    LAUNCH_TIMEOUT);
    }
}

Im Beispiel sorgt die Anweisung @SdkSuppress(minSdkVersion = 18) dafür, die nur auf Geräten mit Android 4.3 (API-Level 18) oder höher laufen, wie vom UI-Automator-Framework gefordert.

Verwenden Sie die Methode findObject(), um eine UiObject2 abzurufen, die Folgendes darstellt: eine Ansicht, die einem bestimmten Auswahlkriterium entspricht. Sie können die UiObject2 wiederverwenden. Instanzen, die Sie in anderen Teilen Ihrer App-Tests erstellt haben. Das Test-Framework „UI Automator“ durchsucht die aktuelle Anzeige nach einem Übereinstimmung jedes Mal, wenn Ihr Test eine UiObject2-Instanz verwendet, um auf eine UI zu klicken oder eine Eigenschaft abfragen.

Das folgende Snippet zeigt, wie Ihr Test UiObject2 erstellen könnte Instanzen, die eine Schaltfläche „Abbrechen“ und eine Schaltfläche „OK“ in einer App darstellen.

Kotlin


val okButton: UiObject2 = device.findObject(
    By.text("OK").clazz("android.widget.Button")
)

// Simulate a user-click on the OK button, if found.
if (okButton != null) {
    okButton.click()
}

Java


UiObject2 okButton = device.findObject(
    By.text("OK").clazz("android.widget.Button")
);

// Simulate a user-click on the OK button, if found.
if (okButton != null) {
    okButton.click();
}

Selector angeben

Wenn Sie auf eine bestimmte UI-Komponente in einer App zugreifen möchten, verwenden Sie die Methode By, um eine BySelector-Instanz zu erstellen. BySelector stellt eine Abfrage für bestimmte Elemente in der angezeigten UI dar.

Wenn mehr als ein übereinstimmendes Element gefunden wird, wird das erste übereinstimmende Element in der Layouthierarchie wird als Ziel-UiObject2 zurückgegeben. Beim Erstellen einer BySelector, können Sie mehrere Properties verketten, um die suchen. Wenn kein passendes UI-Element gefunden wird, wird ein null zurückgegeben.

Mit der Methode hasChild() oder hasDescendant() können Sie mehrere BySelector-Instanzen. Das folgende Codebeispiel zeigt wie Ihr Test eine Suche angeben könnte, um das erste ListView zu finden, das verfügt über ein untergeordnetes UI-Element mit der Texteigenschaft.

Kotlin


val listView: UiObject2 = device.findObject(
    By.clazz("android.widget.ListView")
        .hasChild(
            By.text("Apps")
        )
)

Java


UiObject2 listView = device.findObject(
    By.clazz("android.widget.ListView")
        .hasChild(
            By.text("Apps")
        )
);

Es kann hilfreich sein, den Objektstatus in den Auswahlkriterien anzugeben. Für Wenn Sie eine Liste aller markierten Elemente auswählen möchten, Deaktivieren Sie sie und rufen Sie die Methode checked() mit dem Argument auf „true“ auf.

Aktionen durchführen

Sobald Ihr Test ein UiObject2-Objekt erhalten hat, können Sie die Methoden in Die Klasse UiObject2 zum Ausführen von Nutzerinteraktionen mit der UI-Komponente die durch dieses Objekt dargestellt werden. Sie können folgende Aktionen festlegen:

  • click() : Klickt in die Mitte der sichtbaren Grenzen des UI-Elements
  • drag() : Zieht dieses Objekt an beliebige Koordinaten.
  • setText() : Hiermit wird der Text in einem bearbeitbaren Feld festgelegt, nachdem das Feld Feldinhalt. Umgekehrt löscht die Methode clear() den vorhandenen Text. in einem bearbeitbaren Feld ein.
  • swipe() : Wischbewegung in Richtung einer bestimmten Richtung ausführen
  • scrollUntil(): Führt das Scrollen in die angegebene Richtung aus bis Condition oder EventCondition zufrieden ist.

Mit dem UI-Automator-Test-Framework können Sie einen Intent senden oder einen Test starten eine Activity ohne Shell-Befehle, indem ein Kontext abgerufen wird Objekt durch getContext().

Das folgende Snippet zeigt, wie in Ihrem Test ein Intent verwendet werden kann, um das Ereignis App wird getestet. Dieser Ansatz ist nützlich, wenn Sie nur an Tests interessiert sind. der Rechner App und der Launcher spielt keine Rolle mehr.

Kotlin


fun setUp() {
...

  // Launch a simple calculator app
  val context = getInstrumentation().context
  val intent = context.packageManager.getLaunchIntentForPackage(CALC_PACKAGE).apply {
    addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
  }
  // Clear out any previous instances
  context.startActivity(intent)
  device.wait(Until.hasObject(By.pkg(CALC_PACKAGE).depth(0)), TIMEOUT)
}

Java


public void setUp() {
...

  // Launch a simple calculator app
  Context context = getInstrumentation().getContext();
  Intent intent = context.getPackageManager()
  .getLaunchIntentForPackage(CALC_PACKAGE);
  intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);

  // Clear out any previous instances
  context.startActivity(intent);
  device.wait(Until.hasObject(By.pkg(CALC_PACKAGE).depth(0)), TIMEOUT);
}

Ergebnisse überprüfen

InstrumentationTestCase erweitert TestCase, sodass Sie Standard-JUnit-Assert-Methoden, um zu testen, ob UI-Komponenten in der App zurückgegeben werden die erwarteten Ergebnisse.

Das folgende Snippet zeigt, wie der Test mehrere Schaltflächen in einem der Rechen-App angezeigt wird, klicken Sie der Reihe nach darauf und überprüfen Sie, ob das richtige Ergebnis angezeigt.

Kotlin


private const val CALC_PACKAGE = "com.myexample.calc"

fun testTwoPlusThreeEqualsFive() {
  // Enter an equation: 2 + 3 = ?
  device.findObject(By.res(CALC_PACKAGE, "two")).click()
  device.findObject(By.res(CALC_PACKAGE, "plus")).click()
  device.findObject(By.res(CALC_PACKAGE, "three")).click()
  device.findObject(By.res(CALC_PACKAGE, "equals")).click()

  // Verify the result = 5
  val result: UiObject2 = device.findObject(By.res(CALC_PACKAGE, "result"))
  assertEquals("5", result.text)
}

Java


private static final String CALC_PACKAGE = "com.myexample.calc";

public void testTwoPlusThreeEqualsFive() {
  // Enter an equation: 2 + 3 = ?
  device.findObject(By.res(CALC_PACKAGE, "two")).click();
  device.findObject(By.res(CALC_PACKAGE, "plus")).click();
  device.findObject(By.res(CALC_PACKAGE, "three")).click();
  device.findObject(By.res(CALC_PACKAGE, "equals")).click();

  // Verify the result = 5
  UiObject2 result = device.findObject(By.res(CALC_PACKAGE, "result"));
  assertEquals("5", result.getText());
}

Tests mit UI-Automator auf einem Gerät oder Emulator ausführen

Sie können Tests für UI Automator über Android Studio oder über die Befehlszeile. Legen Sie AndroidJUnitRunner als Standard fest. Instrumentation Runner in Ihrem Projekt.

Weitere Beispiele

Mit der System-UI interagieren

UI Automator kann mit allen Bildschirminhalten interagieren, einschließlich Elemente außerhalb Ihrer App, wie in den folgenden Code-Snippets gezeigt:

Kotlin


// Opens the System Settings.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
device.executeShellCommand("am start -a android.settings.SETTINGS")

Java


// Opens the System Settings.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
device.executeShellCommand("am start -a android.settings.SETTINGS");

Kotlin


// Opens the notification shade.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
device.openNotification()

Java


// Opens the notification shade.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
device.openNotification();

Kotlin


// Opens the Quick Settings shade.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
device.openQuickSettings()

Java


// Opens the Quick Settings shade.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
device.openQuickSettings();

Kotlin


// Get the system clock.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
UiObject2 clock = device.findObject(By.res("com.android.systemui:id/clock"))
print(clock.getText())

Java


// Get the system clock.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
UiObject2 clock = device.findObject(By.res("com.android.systemui:id/clock"));
print(clock.getText());

Auf Übergänge warten

<ph type="x-smartling-placeholder">
</ph> „Bitte nicht stören“ deaktivieren
Abbildung 1: UI-Automator deaktiviert den Modus „Bitte nicht stören“ auf zu testen.

Bildschirmübergänge können einige Zeit in Anspruch nehmen. Die Vorhersage ihrer Dauer ist unzuverlässig. sollte UI Automator nach der Durchführung von Vorgängen warten. UI-Automator bietet hierfür mehrere Methoden:

Das folgende Code-Snippet zeigt, wie UI Automator verwendet wird, um die Funktion in den Systemeinstellungen mit der performActionAndWait()-Methode, die Warten auf Übergänge:

Kotlin


@Test
@SdkSuppress(minSdkVersion = 21)
@Throws(Exception::class)
fun turnOffDoNotDisturb() {
    device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
    device.performActionAndWait({
        try {
            device.executeShellCommand("am start -a android.settings.SETTINGS")
        } catch (e: IOException) {
            throw RuntimeException(e)
        }
    }, Until.newWindow(), 1000)
    // Check system settings has been opened.
    Assert.assertTrue(device.hasObject(By.pkg("com.android.settings")))

    // Scroll the settings to the top and find Notifications button
    var scrollableObj: UiObject2 = device.findObject(By.scrollable(true))
    scrollableObj.scrollUntil(Direction.UP, Until.scrollFinished(Direction.UP))
    val notificationsButton = scrollableObj.findObject(By.text("Notifications"))

    // Click the Notifications button and wait until a new window is opened.
    device.performActionAndWait({ notificationsButton.click() }, Until.newWindow(), 1000)
    scrollableObj = device.findObject(By.scrollable(true))
    // Scroll down until it finds a Do Not Disturb button.
    val doNotDisturb = scrollableObj.scrollUntil(
        Direction.DOWN,
        Until.findObject(By.textContains("Do Not Disturb"))
    )
    device.performActionAndWait({ doNotDisturb.click() }, Until.newWindow(), 1000)
    // Turn off the Do Not Disturb.
    val turnOnDoNotDisturb = device.findObject(By.text("Turn on now"))
    turnOnDoNotDisturb?.click()
    Assert.assertTrue(device.wait(Until.hasObject(By.text("Turn off now")), 1000))
}

Java


@Test
@SdkSuppress(minSdkVersion = 21)
public void turnOffDoNotDisturb() throws Exception{
    device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
    device.performActionAndWait(() -> {
        try {
            device.executeShellCommand("am start -a android.settings.SETTINGS");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }, Until.newWindow(), 1000);
    // Check system settings has been opened.
    assertTrue(device.hasObject(By.pkg("com.android.settings")));

    // Scroll the settings to the top and find Notifications button
    UiObject2 scrollableObj = device.findObject(By.scrollable(true));
    scrollableObj.scrollUntil(Direction.UP, Until.scrollFinished(Direction.UP));
    UiObject2 notificationsButton = scrollableObj.findObject(By.text("Notifications"));

    // Click the Notifications button and wait until a new window is opened.
    device.performActionAndWait(() -> notificationsButton.click(), Until.newWindow(), 1000);
    scrollableObj = device.findObject(By.scrollable(true));
    // Scroll down until it finds a Do Not Disturb button.
    UiObject2 doNotDisturb = scrollableObj.scrollUntil(Direction.DOWN,
            Until.findObject(By.textContains("Do Not Disturb")));
    device.performActionAndWait(()-> doNotDisturb.click(), Until.newWindow(), 1000);
    // Turn off the Do Not Disturb.
    UiObject2 turnOnDoNotDisturb = device.findObject(By.text("Turn on now"));
    if(turnOnDoNotDisturb != null) {
        turnOnDoNotDisturb.click();
    }
    assertTrue(device.wait(Until.hasObject(By.text("Turn off now")), 1000));
}

Weitere Informationen

Weitere Informationen zur Verwendung von UI Automator in Android-Tests finden Sie in der in den folgenden Ressourcen.

Referenzdokumentation:

Produktproben