Scrivere test automatici con Automator di UI

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

UI Automator è un framework di test dell'interfaccia utente adatto per il test dell'interfaccia utente funzionale tra app nel sistema e nelle app installate. Le API UI Automator ti consentono di interagire con gli elementi visibili su un dispositivo, indipendentemente da quale Activity sia attivo, quindi ti consentono di eseguire operazioni come l'apertura del menu Impostazioni o del programma di avvio app in un dispositivo di test. Il test può cercare un componente dell'interfaccia utente utilizzando descrittori utili, come il testo visualizzato nel componente o la descrizione dei contenuti.

Il framework di test UI Automator è un'API basata su strumenti e funziona con il test runner AndroidJUnitRunner. È adatto per scrivere test automatici opaci in stile casella, in cui il codice di test non si basa su dettagli di implementazione interna dell'app di destinazione.

Le funzionalità principali del framework di test UI Automator includono:

• Un'API per recuperare le informazioni sullo stato ed eseguire operazioni sul dispositivo di destinazione. Per ulteriori informazioni, consulta Accedere allo stato del dispositivo.
• API che supportano i test dell'interfaccia utente tra app. Per ulteriori informazioni, consulta le API UI Automator.

Accesso allo stato del dispositivo

Il framework di test UI Automator fornisce una classe UiDevice per accedere ed eseguire operazioni sul dispositivo su cui è in esecuzione l'app di destinazione. Puoi chiamare i relativi metodi per accedere alle proprietà del dispositivo, ad esempio l'orientamento corrente o le dimensioni del display. La classe UiDevice ti consente anche di eseguire le seguenti azioni:

1. Modificare la rotazione del dispositivo.
2. Premi i tasti hardware, ad esempio "Alza il volume".
3. Premi i pulsanti Indietro, Home o Menu.
4. Apri l'area notifiche.
5. Acquisisci uno screenshot della finestra corrente.

Ad esempio, per simulare la pressione del pulsante Home, chiama il metodo UiDevice.pressHome().

API UI Automator

Le API UI Automator ti consentono di scrivere test affidabili senza dover conoscere i dettagli di implementazione dell'app che hai scelto come target. Puoi utilizzare queste API per acquisire e manipolare i componenti dell'interfaccia utente in più app:

• UiObject2: rappresenta un elemento dell'interfaccia utente visibile sul dispositivo.
• BySelector: specifica i criteri per la corrispondenza degli elementi dell'interfaccia utente.
• By: crea BySelector in modo conciso.
• Configurator: consente di impostare i parametri chiave per l'esecuzione dei test di UI Automator.

Ad esempio, il seguente codice mostra come scrivere uno script di test che apre un'app Gmail sul dispositivo:

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()

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);

Configurare UI Automator

Prima di creare il test UI con UI Automator, assicurati di configurare la posizione del codice sorgente del test e le dipendenze del progetto, come descritto in Configurare il progetto per AndroidX Test.

Nel file build.gradle del modulo dell'app per Android, devi impostare un riferimento di dipendenza alla libreria UI Automator:

dependencies {
  ...
  androidTestImplementation("androidx.test.uiautomator:uiautomator:2.3.0")
}

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

Per ottimizzare i test di UI Automator, devi prima ispezionare i componenti dell'interfaccia utente dell'app di destinazione e assicurarti che siano accessibili. Questi suggerimenti di ottimizzazione sono descritti nelle due sezioni successive.

Controllare l'interfaccia utente su un dispositivo

Prima di progettare il test, ispeziona i componenti dell'interfaccia utente visibili sul dispositivo. Per assicurarti che i test di UI Automator possano accedere a questi componenti, controlla che questi componenti abbiano etichette di testo visibili, valori android:contentDescription o entrambi.

Lo strumento uiautomatorviewer fornisce un'interfaccia visiva pratica per ispezionare la gerarchia del layout e visualizzare le proprietà dei componenti dell'interfaccia utente visibili in primo piano sul dispositivo. Queste informazioni ti consentono di creare test più granulari utilizzando UI Automator. Ad esempio, puoi creare un selettore dell'interfaccia utente corrispondente a una proprietà visibile specifica.

Per avviare lo strumento uiautomatorviewer:

1. Avvia l'app di destinazione su un dispositivo fisico.
2. Collega il dispositivo alla tua macchina di sviluppo.
3. Apri una finestra del terminale e vai alla directory <android-sdk>/tools/.
4. Esegui lo strumento con questo comando:

 $ uiautomatorviewer

Per visualizzare le proprietà dell'interfaccia utente per la tua applicazione:

1. Nell'interfaccia di uiautomatorviewer, fai clic sul pulsante Screenshot del dispositivo.
2. Passa il mouse sopra lo snapshot nel riquadro a sinistra per visualizzare i componenti dell'interfaccia utente identificati dallo strumento uiautomatorviewer. Le proprietà sono elencate nel riquadro inferiore a destra e la gerarchia del layout nel riquadro in alto a destra.
3. Se vuoi, fai clic sul pulsante Attiva/disattiva nodi NAF per visualizzare i componenti dell'interfaccia utente non accessibili a UI Automator. Per questi componenti potrebbero essere disponibili solo informazioni limitate.

Per informazioni sui tipi comuni di componenti dell'interfaccia utente forniti da Android, consulta Interfaccia utente.

Assicurati che la tua attività sia accessibile

Il framework di test UI Automator ha un rendimento migliore nelle app che hanno implementato le funzionalità di accessibilità di Android. Quando utilizzi elementi dell'interfaccia utente di tipo View o una sottoclasse di View dell'SDK, non devi implementare il supporto per l'accessibilità, poiché queste classi lo hanno già fatto per te.

Tuttavia, alcune app utilizzano elementi dell'interfaccia utente personalizzati per offrire un'esperienza utente più completa. Questi elementi non forniscono il supporto automatico dell'accessibilità. Se la tua app contiene istanze di una sottoclasse di View che non proviene dall'SDK, assicurati di aggiungere funzionalità di accessibilità a questi elementi completando i seguenti passaggi:

1. Crea una classe concreta che estenda ExploreByTouchHelper.
2. Associa un'istanza della nuova classe a un elemento UI personalizzato specifico chiamando setAccessibilityDelegate().

Per ulteriori indicazioni sull'aggiunta di funzionalità di accessibilità agli elementi delle visualizzazioni personalizzate, consulta Creare visualizzazioni personalizzate accessibili. Per scoprire di più sulle best practice generali per l'accessibilità su Android, consulta Rendere le app più accessibili.

Creare una classe di test di UI Automator

La classe di test UI Automator deve essere scritta nello stesso modo di una classe di test JUnit 4. Per scoprire di più sulla creazione di classi di test JUnit 4 e sull'utilizzo di asserzioni e annotazioni JUnit 4, consulta Creare una classe di test unitario instrumentata.

Aggiungi l'annotazione @RunWith(AndroidJUnit4.class) all'inizio della definizione della classe di test. Devi anche specificare la classe AndroidJUnitRunner, fornita in AndroidX Test, come tuo runner di test predefinito. Questo passaggio è descritto in modo più dettagliato in Eseguire i test di UI Automator su un dispositivo o un emulatore.

Implementa il seguente modello di programmazione nella classe di test di UI Automator:

1. Ottieni un oggetto UiDevice per accedere al dispositivo che vuoi testare chiamando il metodo getInstance() e passando un oggetto Instrumentation come argomento.
2. Ottieni un oggetto UiObject2 per accedere a un componente dell'interfaccia utente visualizzato sul dispositivo (ad esempio la visualizzazione corrente in primo piano) chiamando il metodo findObject().
3. Simula un'interazione utente specifica da eseguire sul componente dell'interfaccia utente chiamando un metodo UiObject2. Ad esempio, chiama scrollUntil() per scorrere e setText() per modificare un campo di testo. Puoi chiamare le API nei passaggi 2 e 3 più volte, se necessario, per testare interazioni utente più complesse che coinvolgono più componenti dell'interfaccia utente o sequenze di azioni utente.
4. Verifica che l'interfaccia utente rifletta lo stato o il comportamento previsto dopo l'esecuzione di queste interazioni con l'utente.

Questi passaggi sono descritti in maggiore dettaglio nelle sezioni seguenti.

Accedere ai componenti dell'interfaccia utente

L'oggetto UiDevice è il modo principale per accedere e manipolare lo stato del dispositivo. Nei test, puoi chiamare i metodi UiDevice per verificare lo stato di varie proprietà, ad esempio l'orientamento corrente o le dimensioni del display. Il test può utilizzare l'oggetto UiDevice per eseguire azioni a livello di dispositivo, come forzare la rotazione del dispositivo in una posizione specifica, premere i pulsanti hardware del D-pad e premere i pulsanti Home e Menu.

È buona prassi avviare il test dalla schermata Home del dispositivo. Dalla schermata Home (o da un'altra posizione iniziale scelta sul dispositivo), puoi chiamare i metodi forniti dall'API UI Automator per selezionare e interagire con elementi dell'interfaccia utente specifici.

Il seguente snippet di codice mostra come il test potrebbe recuperare un'istanza diUiDevice e simulare la pressione del tasto Home:

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

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);
    }
}

Nell'esempio, l'istruzione @SdkSuppress(minSdkVersion = 18) contribuisce a garantire che i test vengano eseguiti solo su dispositivi con Android 4.3 (livello API 18) o versioni successive, come richiesto dal framework UI Automator.

Utilizza il metodo findObject() per recuperare un UiObject2 che rappresenta una visualizzazione corrispondente a determinati criteri del selettore. Puoi riutilizzare le UiObject2 istanze che hai creato in altre parti del test dell'app, se necessario. Tieni presente che il framework di test di UI Automator cerca una corrispondenza nella visualizzazione corrente ogni volta che il test utilizza un'istanza di UiObject2 per fare clic su un elemento dell'interfaccia utente o eseguire una query su una proprietà.

Lo snippet seguente mostra come il test potrebbe creare UiObject2 istanze che rappresentano un pulsante Annulla e un pulsante OK in un'app.

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()
}

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();
}

Specifica un selettore

Se vuoi accedere a un componente dell'interfaccia utente specifico in un'app, utilizza la classe By per creare un'istanza BySelector. BySelector rappresenta una query per elementi specifici nell'interfaccia utente visualizzata.

Se viene trovato più di un elemento corrispondente, viene restituito come target UiObject2 il primo elemento corrispondente nella gerarchia del layout. Quando crei un BySelector, puoi concatenare più proprietà per perfezionare la sua ricerca. Se non viene trovato alcun elemento dell'interfaccia utente corrispondente, viene restituito un valore null.

Puoi utilizzare il metodo hasChild() o hasDescendant() per nidificare più istanze di BySelector. Ad esempio, il seguente esempio di codice mostra come il test potrebbe specificare una ricerca per trovare il primo ListView che ha un elemento dell'interfaccia utente secondario con la proprietà text.

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

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

Può essere utile specificare lo stato dell'oggetto nei criteri del selettore. Ad esempio, se vuoi selezionare un elenco di tutti gli elementi selezionati in modo da poterli deselezionare, chiama il metodo checked() con l'argomento impostato su true.

Esegui azioni

Una volta che il test ha ottenuto un oggetto UiObject2, puoi chiamare i metodi della classe UiObject2 per eseguire interazioni utente sul componente dell'interfaccia utente rappresentato dall'oggetto. Puoi specificare azioni come:

• click() : fa clic al centro dei limiti visibili dell'elemento dell'interfaccia utente.
• drag() : trascina questo oggetto in coordinate arbitrarie.
• setText() : imposta il testo in un campo modificabile dopo aver cancellato i contenuti del campo. Al contrario, il metodo clear() cancella il testo esistente in un campo modificabile.
• swipe() : esegue l'azione di scorrimento nella direzione specificata.
• scrollUntil(): esegue l'azione di scorrimento nella direzione specificata fino a quando non viene soddisfatta la condizione Condition o EventCondition.

Il framework di test di UI Automator ti consente di inviare un Intent o avviare un'attività senza utilizzare i comandi shell, ottenendo un oggetto Context tramite getContext().

Lo snippet seguente mostra come il test può utilizzare un Intent per avviare l'app in test. Questo approccio è utile se ti interessa solo testare l'app Calcolatrice e non ti interessa il programma di avvio.

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

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);
}

Verificare i risultati

InstrumentationTestCase estende TestCase, quindi puoi utilizzare metodi Assert JUnit standard per verificare che i componenti dell'interfaccia utente nell'app restituiscano i risultati previsti.

Lo snippet seguente mostra in che modo il test può individuare diversi pulsanti in un'app calcolatrice, fare clic su di essi in ordine e verificare che venga visualizzato il risultato corretto.

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

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());
}

Eseguire i test di UI Automator su un dispositivo o un emulatore

Puoi eseguire i test di UI Automator da Android Studio o dalla riga di comando. Assicurati di specificare AndroidJUnitRunner come esecuzione di strumentazione predefinita nel progetto.

Altri esempi

Interagire con l'interfaccia utente di sistema

UI Automator può interagire con tutto ciò che è sullo schermo, inclusi gli elementi di sistema esterni all'app, come mostrato negli snippet di codice seguenti:

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

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

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

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

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

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

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

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

Attendi le transizioni

Le transizioni tra le schermate possono richiedere tempo e la previsione della loro durata non è affidabile, quindi devi chiedere a UI Automator di attendere dopo aver eseguito le operazioni. UI Automator offre più metodi per questo:

• UiDevice.performActionAndWait(Runnable action, EventCondition<U> condition, long timeout): ad esempio, per fare clic su un pulsante e attendere che venga visualizzata una nuova finestra, chiama device.performActionAndWait(() -> button.click(), Until.newWindow(), timeout)
• UiDevice.wait(Condition<Object, U> condition, long timeout): ad esempio, per attendere che sul dispositivo sia presente un determinato UiObject2, chiama device.wait(Until.hasObject(By.text("my_text")), timeout);
• UiObject2.wait(@NonNull Condition<Object, U> condition, long timeout): ad esempio, per attendere che una casella di controllo venga selezionata, chiama checkbox.wait(Until.checked(true), timeout);
• UiObject2.clickAndWait(@NonNull EventCondition<U> condition, long timeout): ad esempio, per fare clic su un pulsante e attendere che venga visualizzata una nuova finestra, chiama button.clickAndWait(Until.newWindow(), timeout);
• UiObject2.scrollUntil(@NonNull Direction direction, @NonNull Condition<Object, U> condition): ad esempio, per scorrere verso il basso finché non viene visualizzato un nuovo oggetto, chiama object.scrollUntil(Direction.DOWN, Until.hasObject(By.text('new_obj')));
• UiObject2.scrollUntil(@NonNull Direction direction, @NonNull EventCondition<U> condition): ad esempio, per scorrere verso il basso fino in fondo, chiama object.scrollUntil(Direction.DOWN, Until.scrollFinished(Direction.DOWN));

Il seguente snippet di codice mostra come utilizzare UI Automator per disattivare la modalità Non disturbare nelle Impostazioni di sistema utilizzando il metodo performActionAndWait() che attende le transizioni:

@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))
}

@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));
}

Risorse aggiuntive

Per ulteriori informazioni sull'utilizzo di UI Automator nei test Android, consulta le seguenti risorse.

Documentazione di riferimento:

• Riferimento all'API UI Automator

Campioni

• BasicSample: esempio di UI Automator di base.