Controllo quando un test di automazione termina - Espresso

Question

Ho una situazione insolita che sto testando. Sto usando l'espresso per scrivere i miei test. So che l'espresso e la strumentazionetestcase non è destinato a farlo.

Ho un ascoltatore che ho creato in una delle mie classi che mi avviserà di un cambiamento di un determinato valore. Io uso l'ascoltatore nella mia suite di test.

Quando ricevo il valore dall'ascoltatore, ho bisogno di affermare che il valore è stato modificato come tale.

Il mio problema è il test terminerà prima che riceverò il valore modulo il listener.

    private void sendSpeedChanges() {
    setStaticSpeed(new Random().nextInt(10) + 2);
    try {
        runTestOnUiThread(new Runnable() {
            @Override
            public void run() {
                consoleActivity.onSpeedChanged(getStaticSpeed(), false);
            }
        });
    } catch (Throwable throwable) {
        throwable.printStackTrace();
    }

}

private void createSpeedDelegate() {
    EspressoMachineValues.setOnSpeedChangeListener(new EspressoMachineValues.OnSpeedChangeListener() {
        @Override
        public void onSpeedChanged(double speed) {
            //assert speed is correct.
            assertTrue(getStaticSpeed() == speed);
        }
    });

}

.

Questi sono i due metodi che sto usando. Il createSpeedDelegate() è chiamato all'inizio. Quindi chiamo sendSpeedChanges. Ho bisogno di fare questo x-quantità di volte.

---

.

Nota:

.
• ci vogliono circa 200 millisecondi per recuperare informazioni (in media).
• Non posso chiamare sendSpeedChanges() finché non ho controllato il valore in onSpeedChange()
• Non posso utilizzare Thread.sleep(); perché il listener è sul thread principale.

Ho provato Aggiunta di un getInstrumentation().wait(2000); e anche getInstrumentation().waitForIdleSync(); Ovviamente, né funzionano.

In un mondo perfetto, lo farei:

   for (int i = 0; i < 42; i++) {
        sendSpeedChanges();
        i++;
    }

.

Ma, questo non aspetterà che il valore sia controllato. E se attendo il valore, il test runner pensa che tutti i test siano eseguiti e termina.

La mia domanda è che ci sarebbe un modo per controllare quando il test si chiude? Anche se i miei test appaiono da fare.

Answer 1

Nel test è necessario creare un'istruzione di controllo che mantiene quel test in esecuzione finché vuoi che sia eseguito.

while(myTestNeedsToRun) {
    if(speedChangeReceived) {
        sendSpeedChange();
        speedChangeReceived = false;
    }
}

private void createSpeedDelegate() {
   EspressoMachineValues.setOnSpeedChangeListener(new EspressoMachineValues.OnSpeedChangeListener() {
    @Override
    public void onSpeedChanged(double speed) {
        //assert speed is correct.
        assertTrue(getStaticSpeed() == speed);
        speedChangedReceived = true;
    }
});

.

Una volta deciso, hai finito di eseguire il test, impostare myTestNeedsToRun = false e quindi il test terminerà.

Answer 2

In alternativa, è possibile creare un IDLINGRESOURCE per monitorare la tua velocità. IdlingResource è il modo in cui l'espresso utilizza per verificare che il filo principale sia inattivo o che non ci siano asynctasks in esecuzione nel pool asynctSask.

Avere un boook a CoutingidlingResource Classe nel codice sorgente della biblioteca. Potresti implementare qualcosa di simile a quello. Nel tuo caso, potrebbe essere qualcosa del genere:

[...]

private int mTargetSpeed;
private volatile ResourceCallback resourceCallback;

@Override
public boolean isIdleNow() {
  boolean isIdle = false;
  if (getStaticSpeed() == mTargetSpeed) {
     isIdle = true;
     resourceCallback.onTransitionToIdle();
  } else {
     isIdle = false;
  }

  return isIdle;
}

.

sui test, ogni volta che vuoi aspettare che la velocità raggiunga il livello desiderato, dovresti fare:

[...]
SpeedIdlingResource speedIdlingResource = new SpeedIdlingResource ("my_idling_resource");
Espresso.registerIdlingResources(speedIdlingResource);

.

In questo modo, l'espresso bloccherà fino a quando la tua risorsa di minimazione racconterà al framework il tuo speedmonitor è inattivo. Questo è di buon modo in cui si sfrutta tutto il framework di sincronizzazione del caffè espresso per monitorare quando hai raggiunto la velocità di destinazione, quindi i tuoi test sarebbero più affidabili e più veloci del fare un'attesa occupata.