Criar testes instrumentados

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.

Exemplo

Codelabs