Os testes instrumentados são executados em dispositivos Android, físicos ou emulados. Conforme Assim, eles podem aproveitar as APIs de framework do Android. Testes instrumentados proporcionam mais fidelidade do que os testes locais, embora eles executem muito mais lentamente.
Recomendamos o uso de testes instrumentados somente nos casos em que é necessário fazer testes o comportamento de um dispositivo real. O AndroidX Test oferece várias bibliotecas. que facilitam a criação de testes instrumentados quando necessário.
Configurar o ambiente de teste
No projeto do Android Studio, armazene os arquivos de origem dos arquivos
testes em module-name/src/androidTest/java/
. Esse diretório já existe quando
você cria um novo projeto e contém um exemplo de teste instrumentado.
Antes de começar, adicione APIs de teste do AndroidX, que permitem rápido
criar e executar código de teste instrumentado para apps. O AndroidX Test inclui uma
O executor de testes JUnit 4 ,o AndroidJUnitRunner
, e APIs para testes funcionais de interface.
como o Espresso, o UI Automator e o teste do Compose.
Você também precisa configurar as dependências de testes do Android para que seu projeto use o executor de testes e as APIs de regras disponibilizadas 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"
}
Você pode encontrar as versões mais recentes nas notas da versão do AndroidX e no Compose. Notas da versão da interface.
Para usar classes de testes do JUnit 4 e ter acesso a recursos como filtragem de testes,
especifique AndroidJUnitRunner como a instrumentação de teste padrão.
no seu projeto incluindo a seguinte configuração no arquivo
arquivo build.gradle
de nível de módulo:
android {
defaultConfig {
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
}
}
Criar uma classe de teste instrumentado
A classe de teste de instrumentação precisa ser do tipo JUnit 4 semelhante à a classe descrita na seção sobre como criar testes locais.
Para criar uma classe de teste de instrumentação do JUnit 4, especifique AndroidJUnit4
como
executor de testes padrão.
O exemplo a seguir mostra como criar um teste instrumentado para verificar
se a interface Parcelable foi implementada corretamente para o
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 instrumentados
Os testes instrumentados podem ser executados em dispositivos reais ou emuladores. No Android No guia do Studio, você aprende a:
Outros recursos
Os testes de interface geralmente são testes instrumentados que verificam o comportamento correto dos na interface. Eles usam frameworks como o Espresso ou o Compose Test. Para saber mais, leia o guia de teste de interface.
Para saber mais sobre o uso de testes de instrumentação, consulte as páginas a seguir: do Google Cloud.