As execuções de teste instrumentadas são executadas em dispositivos Android, sejam físicos ou emulados. Assim, eles podem aproveitar as APIs do framework do Android. Portanto, os testes instrumentados oferecem mais fidelidade do que os testes locais, embora sejam executados de forma muito mais lenta.
Recomendamos o uso de testes de instrumentação apenas nos casos em que é necessário testar o comportamento de um dispositivo real. O AndroidX Test oferece várias bibliotecas que facilitam a criação de testes de instrumentação quando necessário.
Configurar o ambiente de teste
No projeto do Android Studio, os arquivos de origem dos testes instrumentados
são armazenados em module-name/src/androidTest/java/. Esse diretório já existe quando
você cria um novo projeto e contém um exemplo de teste de instrumentação.
Antes de começar, adicione as APIs de teste do AndroidX, que permitem criar e executar rapidamente códigos de teste de instrumentação para seus apps. O AndroidX Test inclui um
executor de teste JUnit 4, AndroidJUnitRunner, e APIs para testes funcionais de interface,
como Espresso, UI Automator e teste do Compose.
Também é necessário configurar as dependências de teste do Android para que seu projeto use o executor de teste e as APIs de regras fornecidas pelo AndroidX Test.
No arquivo build.gradle de nível superior do app, é necessário especificar essas bibliotecas
como dependências:
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"
}
Confira as versões mais recentes nas Notas da versão do AndroidX e nas Notas da versão da interface do Compose.
Para usar as classes de teste do JUnit 4 e ter acesso a recursos como filtragem de testes,
especifique AndroidJUnitRunner como o executor de instrumentação de teste padrão
no seu projeto, incluindo a seguinte configuração no arquivo build.gradle
do módulo do app:
android {
defaultConfig {
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
}
}
Criar uma classe de teste de instrumentação
A classe de teste de instrumentação precisa ser uma classe de teste JUnit 4 semelhante à classe descrita na seção sobre como criar testes locais.
Para criar uma classe de teste instrumentada do JUnit 4, especifique AndroidJUnit4 como o
executor de teste padrão.
O exemplo abaixo mostra como escrever um teste de instrumentação para verificar
se a interface Parcelable foi implementada corretamente para a
classe LogHistory:
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); } }
Executar testes de instrumentação
Os testes instrumentados podem ser executados em dispositivos reais ou emuladores. No guia do Android Studio, você aprende a:
Outros recursos
Os testes de interface geralmente são testes instrumentados que verificam o comportamento correto da interface. Eles usam frameworks como o Espresso ou o Compose Test. Para saber mais, leia o guia de testes de interface.
Para mais informações sobre como usar testes de instrumentação, consulte os recursos abaixo.