Testar no Android Studio

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

O Android Studio foi projetado para facilitar testes. Ele contém vários recursos para simplificar a criação, execução e análise de testes. Você pode configurar testes que vão ser executados na máquina local ou testes instrumentados que vão ser executados em um dispositivo. É fácil realizar um único teste ou um grupo específico de testes em um ou mais dispositivos. Os resultados do teste são mostrados diretamente no Android Studio.

Figura 1. Visão geral dos resultados de um teste no Android Studio.

Esta página explica como gerenciar testes no Android Studio. Para aprender a programar testes automatizados do Android, consulte Testar apps no Android.

Tipos e locais de teste

A localização dos testes depende do tipo de teste criado. Os projetos do Android têm diretórios de código-fonte padrão para testes de unidade locais e testes instrumentados.

Os testes de unidade locais estão localizados em module-name/src/test/java/. Eles são executados na máquina virtual Java (JVM) local do computador e usados para minimizar o tempo de execução quando os testes não têm dependências de framework do Android ou quando você consegue duplicar testes para essas dependências. Para ver mais informações sobre a criação de testes de unidade locais, consulte Criar testes de unidade locais.

Os testes instrumentados estão localizados em $module-name/src/androidTest/java/. Eles são executados em um dispositivo ou emulador de hardware e têm acesso a APIs de Instrumentation que dão acesso a informações, por exemplo, a classe Context, no app que você está testando, permitindo o controle com o código de teste. Como os testes instrumentados são criados em um APK separado, eles têm o próprio arquivo AndroidManifest.xml. Esse arquivo é gerado automaticamente, mas você pode criar sua própria versão em $module-name/src/androidTest/AndroidManifest.xml. Ela vai ser mesclada ao manifesto gerado. Os testes instrumentados são usados na criação de testes de integração e funcionalidade de IU para automatizar a interação do usuário ou quando os testes têm dependências do Android que não podem ser simuladas em testes. Para ver mais informações sobre a criação de testes instrumentados, consulte Criar testes instrumentados e Automatizar testes de IU.

Você pode colocar seus testes em diretórios de variantes de build específicas para limitar a testagem. Por exemplo, é possível colocar alguns testes de unidade locais em $module-name/src/testMyFlavor/java/ para que os testes usem o app criado com o código-fonte dessa variação. Para ver mais informações sobre a criação desses testes personalizados, consulte Criar um teste instrumentado para uma variante de build.

Quando você cria um novo projeto ou adiciona um módulo de app, o Android Studio cria os conjuntos de origem de teste já listados e inclui um arquivo de teste de exemplo em cada um deles. Você pode vê-los na janela Project, como mostrado na Figura 2.

Figura 2. Os (1) testes instrumentados e os (2) testes da JVM local do projeto podem ser vistos nas visualizações Project (à esquerda) ou Android (à direita).

Criar novos testes

Você pode adicionar um novo teste a uma classe ou método específico diretamente do código-fonte seguindo estas etapas:

  1. Abra o arquivo de origem que contém o código que você quer testar.
  2. Coloque o cursor no nome da classe ou do método que você quer testar e pressione Ctrl + Shift + T ou Command + Shift + T no macOS.
  3. No pop-up exibido, clique em Create New Test….
  4. Na caixa de diálogo Create Test, escolha JUnit4, edite os campos e métodos que você quer gerar e clique em OK.
  5. Na caixa de diálogo Choose Destination Directory, clique no conjunto de origem correspondente ao tipo de teste que você quer criar: androidTest para um teste instrumentado ou test para um teste de unidade local. Em seguida, clique em OK.

Como alternativa, você pode criar um arquivo de teste genérico no conjunto de origem de teste adequado desta forma:

  1. Na janela Project à esquerda, clique no menu suspenso e selecione a visualização Android.
  2. Clique com o botão direito do mouse no diretório java e selecione New > Java Class ou New > Kotlin Class/File. Como alternativa, você pode selecionar o diretório java e usar o atalho Ctrl + N ou Command + N no macOS.
  3. Na caixa de diálogo Choose Destination Directory, clique no conjunto de origem correspondente ao tipo de teste que você quer criar: androidTest para um teste instrumentado ou test para um teste de unidade local. Em seguida, clique em OK.
  4. Atribua um nome ao arquivo e clique em OK.

Se o app não for compilado depois de adicionar um teste, confira se as dependências corretas da biblioteca de teste estão configuradas. Consulte Criar testes locais e Criar testes instrumentados para ver as dependências corretas.

Executar testes

Antes de executar qualquer teste, confira se o projeto está totalmente sincronizado com o Gradle clicando em Sync Project na barra de ferramentas. Você pode executar testes com diferentes níveis de granularidade:

  • Para executar todos os testes em um diretório ou arquivo, abra a janela "Project" e siga um dos procedimentos abaixo:

    • Clique com o botão direito do mouse em um diretório ou arquivo e clique em Run .
    • Selecione o diretório ou arquivo e use o atalho Ctrl + Shift + R.
  • Para executar todos os testes em uma classe ou método específico, abra o arquivo de teste no editor de código e siga um dos procedimentos abaixo:

    • Pressione o ícone Run test no gutter (link em inglês).
    • Clique com o botão direito do mouse na classe ou método de teste e clique em Run .
    • Selecione a classe ou método de teste e use o atalho Ctrl + Shift + R.

Os testes instrumentados vão ser executados em um dispositivo físico ou emulador. Para saber mais sobre a configuração de dispositivos físicos, consulte Executar apps em um dispositivo de hardware. Para saber mais sobre a configuração de emuladores, consulte Executar apps no Android Emulator.

Configurar a execução do teste

Por padrão, testes são executados usando a configuração de execução padrão do Android Studio. Se você precisar mudar algumas configurações de execução, como o executor de instrumentação e opções de implantação, faça as modificações na caixa de diálogo Run/Debug Configurations (clique em Run > Edit Configurations).

Executor de testes unificado do Gradle

O Plug-in do Android para Gradle 7.1.0 e o Android Studio Bumblebee e versões mais recentes usam a implementação própria do Gradle no executor de testes instrumentados Android para realizar esse tipo de teste. Com o mesmo executor de testes, os resultados têm mais probabilidade de ser consistentes, independente de você usar o AGP na linha de comando, como em um servidor de integração contínua, ou no Android Studio.

Figura 3. O executor de testes unificado do Gradle.

As versões anteriores do Android Studio usam o executor de testes instrumentados Android do IntelliJ em vez do executor de testes instrumentados Android do Gradle. Portanto, se você não estiver usando a versão mais recente do Android Studio, dependendo da execução dos testes no Android Studio ou na linha de comando com o plug-in Gradle, talvez você veja resultados de teste diferentes, como testes sendo aprovados com um executor e falhando com outro.

Figura 4. Executores de testes discretos nas versões mais antigas do Android Studio.

Se você já salvou configurações de testes instrumentados no projeto, elas vão usar o Gradle para executar testes no dispositivo conectado. É possível criar uma nova configuração de testes instrumentados usando a ação de gutter ao lado da classe ou do método de teste, conforme mostrado abaixo.

Figura 5. Executar testes com a ação de gutter.

Ao executar seus testes instrumentados, você pode confirmar se o Android Studio está usando o executor de testes do Gradle inspecionando a saída do teste na matriz de teste da saída de tarefas do Gradle.

Desativar o executor de testes unificado do Gradle

Por padrão, o Android Studio Bumblebee usa o Gradle para executar testes de instrumentação. Se você tiver algum problema, desative esse comportamento da seguinte maneira:

  1. Selecione File > Settings > Build, Execution, Deployment > Testing (ou Android Studio > Preferences > Build, Execution, Deployment > Testing no MacOS).
  2. Desmarque a caixa ao lado de Run Android instrumented tests using Gradle e clique em OK.

Ao executar testes fora do Android Studio, você também pode reverter para comportamentos anteriores seguindo um destes procedimentos:

  • Use o seguinte parâmetro de linha de comando: -Pandroid.experimental.androidTest.useUnifiedTestPlatform=false
  • Adicione este parâmetro ao arquivo gradle.properties do projeto: android.experimental.androidTest.useUnifiedTestPlatform=false

Para receber ajuda com a resolução de problemas, informe um bug.

Executar em vários dispositivos em paralelo

Por padrão, os testes instrumentados são executados em um emulador ou dispositivo físico. Para ver como os testes se comportam em um conjunto maior de dispositivos, selecione mais dispositivos seguindo as etapas abaixo:

  1. Antes de executar os testes, abra o menu suspenso de dispositivo de destino e selecione Select Multiple Devices….

    Figura 6. Menu suspenso "Select Multiple Devices".

  2. Selecione os dispositivos que quer testar e clique em OK.

  3. Confira se o texto no menu suspenso de destino mudou para Multiple Devices e clique em Run .

  4. A janela de ferramentas da matriz de teste mostra os resultados do teste para cada configuração de dispositivo selecionada.

    Figura 7. Resultados do teste na janela de ferramentas da matriz de teste.

  5. Você pode clicar em um teste específico para inspecionar o resultado no painel de saída. Também é possível classificar os testes clicando nas várias colunas.

Executar no Firebase Test Lab

Com o Firebase Test Lab, você pode testar seu app simultaneamente em vários dispositivos e configurações Android conhecidos (diferentes combinações de localidade, orientação, tamanho da tela e versão da plataforma). Esses testes são executados em dispositivos físicos e virtuais em data centers remotos do Google. Os resultados do teste incluem registros e detalhes de qualquer falha do app.

Para começar a usar o Firebase Test Lab, siga estas etapas:

  1. Crie uma Conta do Google, caso ainda não tenha uma.
  2. No Console do Firebase, clique em Criar novo projeto. Dentro da cota diária sem custos do plano Spark, nenhuma cobrança é realizada para testar o app usando o Test Lab.

O Android Studio oferece ferramentas integradas que permitem configurar a implantação dos seus testes no Firebase Test Lab. Depois de criar um projeto do Firebase, crie uma configuração de teste e execute seus testes:

  1. No menu principal, clique em Executar > Editar configurações.
  2. Clique em Adicionar nova configuração e selecione Testes instrumentados para Android.
  3. Digite ou selecione os detalhes do seu teste, como, nome, tipo de módulo, tipo de teste e classe de testes.
  4. No menu suspenso de Destino, em Opções de destino de implantação, selecione Firebase Test Lab Device Matrix.
  5. Se você não tiver feito login, clique em Fazer login com o Google e permita que o Android Studio acesse sua conta.
  6. Ao lado de Cloud Project, selecione seu projeto do Firebase na lista.
  7. Ao lado de Matrix configuration, selecione uma das configurações padrão na lista suspensa ou crie sua própria configuração pressionando o botão para abrir uma caixa de diálogo . Você pode selecionar um ou mais dispositivos, versões do Android, localidades e orientações de tela para testar seu app. Ao gerar os resultados dos testes, o Firebase Test Lab testa seu app em todas as combinações selecionadas.
  8. Clique em OK na caixa de diálogo de configuração de execução/depuração para sair.
  9. Para executar seus testes, clique em Run .

Figura 8. Como criar uma configuração de teste no Firebase Test Lab.

Analisar resultados do teste

Quando o Firebase Test Lab conclui a execução dos testes, a janela Run é aberta para exibir os resultados, conforme mostrado na Figura 9. Pode ser necessário clicar em Show Passed para ver todos os testes executados.

Figura 9. Resultados de testes instrumentados usando o Firebase Test Lab.

Também é possível analisar seus testes na Web com o link exibido no início do registro de execução de testes da janela Run.

Ver cobertura de teste

A ferramenta de cobertura de teste está disponível para que testes de unidade locais monitorem o percentual e as áreas do código do app cobertas pelos testes de unidade. Use a ferramenta de cobertura de teste para determinar se você testou corretamente os elementos, classes, métodos e linhas de código que compõem o app.

Para executar testes com cobertura, siga as mesmas etapas descritas em Executar testes. No entanto, em vez de clicar em Run , clique em Run test-name with coverage . Na janela Project, essa opção pode estar oculta em More Run/Debug. Também é possível definir as configurações de cobertura na caixa de diálogo Run/Debug Configurations da guia Code Coverage.

Figura 10. Porcentagens de cobertura de código em um aplicativo.

Ver os resultados dos testes

Quando você executa um ou mais testes no Android Studio, os resultados são exibidos na janela Run. A Figura 11 mostra um teste aprovado.

Figura 11. Os resultados do teste são exibidos na janela "Run".

A janela Run exibe os testes em uma visualização em árvore à esquerda e os resultados e mensagens do pacote de testes atual no painel à direita. Use as barras de ferramentas, menus de contexto e ícones de status para gerenciar os resultados do teste, desta maneira:

  1. Use a barra de ferramentas de execução para executar novamente ou interromper o teste atual, executar novamente testes com falha (essa opção não é exibida porque só está disponível para testes de unidade), pausar a saída e fazer o despejo de linhas de execução.
  2. Use a barra de ferramentas de testes para filtrar e classificar os resultados. Também é possível expandir ou fechar nós, mostrar a cobertura do teste e importar ou exportar os resultados.
  3. Você pode clicar no menu de contexto para acompanhar o teste em execução, exibir estatísticas in-line, rolar para o stack trace, abrir o código-fonte em uma exceção, rolar automaticamente até a origem e selecionar o primeiro teste com falha quando a execução do teste terminar.
  4. Os ícones de status de teste indicam se um teste apresentou um erro, foi ignorado, falhou, está em andamento, terminou, está pausado, foi cancelado ou não foi executado.
  5. Com o botão direito do mouse, clique em uma linha na visualização em árvore para exibir um menu de contexto que permite executar testes no modo de depuração. Abra o arquivo de código-fonte do teste ou acesse a linha que está sendo testada.

Analisar falhas no teste

Quando um ou mais dos seus testes falham, a janela de resultados mostra um sinal de aviso e o número de falhas (por exemplo, "Tests failed: 1"):

Figura 12. Detalhes de falhas no teste no painel de saída.

Quando você clica no teste com falha na visualização em árvore à esquerda, o painel de saída à direita mostra os detalhes. O valor esperado é exibido ao lado do valor real para que você possa os comparar. O link Click to see difference abre um visualizador de diferenças em que é possível ver os resultados lado a lado.

Saiba mais

Esta página aborda as etapas básicas para criar e executar seu primeiro teste no Android Studio. Também é possível executar testes na linha de comando. Confira também a documentação do IntelliJ sobre testes (em inglês). Para ver mais informações sobre a configuração de testes em um conjunto de testes maior, consulte Configuração de testes avançados.