Skip to content

Most visited

Recently visited

navigation

Testar o aplicativo

O Android Studio foi projetado para facilitar testes. Com apenas alguns cliques, você pode configurar um teste do JUnit executado na JVM local ou um teste instrumentado executado em um dispositivo. Naturalmente, é possível ampliar os recursos de teste integrando estruturas de teste como Mockito para testar chamadas a APIs do Android em testes de unidade locais e Espresso ou UI Automator para exercitar a interação do usuário nos testes instrumentados. Você pode gerar automaticamente testes do Espresso usando o Espresso Test Recorder.

Esta página oferece informações básicas para adicionar novos testes ao aplicativo e executá-los no Android Studio.

Para obter instruções mais detalhadas para programar testes, consulte Primeiros passos sobre testes.

Tipos e localização de testes

A localização do código de teste depende do tipo de teste criado. O Android Studio oferece diretórios de código-fonte (conjuntos de origem) para os dois tipos de teste a seguir:

Testes de unidade locais

Localizados em module-name/src/test/java/.

Esses testes são executados na Java Virtual Machine (JVM) local do computador. Use esses testes para minimizar o tempo de execução quando os testes não têm dependências de estrutura Android ou quando você pode simular essas dependências.

Em tempo de execução, estes testes são executados usando uma versão modificada de android.jar, em que todos os modificadores final foram retirados. Isso permite o uso de bibliotecas de simulação como o Mockito.

Testes instrumentados

Localizados em module-name/src/androidTest/java/.

São testes executados em um dispositivo ou emulador de hardware. Esses testes têm acesso a APIs de instrumentação, disponibilizando acesso a informações como o Context do aplicativo testado e permitem controlar o aplicativo sendo testado do código de teste. Use esses testes ao programar testes de integração e funcionais de IU para automatizar a interação do usuário ou quando os testes têm dependências do Android que os objetos simulados não conseguem atender.

Como os testes instrumentados são compilados em um APK (separado do APK do aplicativo), eles devem ter seu próprio arquivo AndroidManifest.xml. No entanto, o Gradle gera automaticamente esse arquivo durante a compilação, por isso ele não é visível no conjunto de origem do projeto. Se necessário, você pode adicionar seu próprio arquivo de manifesto, como para especificar um valor diferente para `minSdkVersion` ou fazer registro de ouvintes de execução apenas para os testes. Na compilação do aplicativo, o Gradle mescla vários arquivos de manifesto em um único manifesto.

A compilação do Gradle interpreta esses conjuntos de origem de teste da mesma forma que interpreta os conjuntos de origem do aplicativo do projeto, o que permite criar testes de acordo com as variações de compilação.

Quando você cria um novo projeto ou adiciona um módulo de aplicativo, o Android Studio cria os conjuntos de origem de teste listados acima e inclui uma amostra de arquivo de teste em cada um deles. Eles podem ser vistos na janela Project, como mostrado na figura 1.

Figura 1. Os (1) testes instrumentados e os (2) testes da JVM local do projeto estão visíveis na visualização Project (esquerda) ou Android (direita).

Adicionar um novo teste

Para criar um teste de unidade local ou um teste instrumentado, você pode criar um novo teste para uma classe ou método específico seguindo estas etapas:

  1. Abra o arquivo Java que contém o código que você quer testar.
  2. Clique na classe ou método que deseja testar e pressione Ctrl+Shift+T (⇧⌘T).
  3. No menu exibido, clique em Create New Test.
  4. Na caixa de diálogo Create Test, edite os campos e selecione os métodos a serem gerados 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. Clique em OK.

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

  1. Na janela Project à esquerda, clique no menu suspenso e selecione a visualização Project.
  2. Amplie a pasta do módulo adequado e a pasta src aninhada. Para adicionar um teste de unidade local, amplie a pasta test e a pasta java aninhada; para adicionar um teste instrumentado, amplie a pasta androidTest e a pasta java aninhada.
  3. Clique com o botão direito no diretório do pacote Java e selecione New > Java Class.
  4. Atribua um nome ao arquivo e clique em OK.

Além disso, não deixe de especificar as dependências das bibliotecas de teste no arquivo build.gradle do módulo do aplicativo:

dependencies {
    // Obrigatório para testes de unidade locais (framework JUnit 4)
    testCompile 'junit:junit:4.12'

    // Obrigatório para testes instrumentados
    androidTestCompile 'com.android.support:support-annotations:24.0.0'
    androidTestCompile 'com.android.support.test:runner:0.5'
}

Para obter outras dependências de biblioteca opcionais e mais informações sobre como escrever testes, consulte Criar testes de unidade locais e Criar testes de unidade instrumentados.

Crie um teste instrumentado para uma variação de compilação

Se o projeto incluir variações de compilação com conjuntos de origem únicos, você poderá precisar de conjuntos de origem de testes instrumentados. A criação de testes instrumentados em conjuntos de origem correspondentes às variações de compilação manterá o código de teste organizado e permitirá executar apenas os testes necessários para uma determinada variação de compilação.

Para adicionar um conjunto de origem de teste para a variação de compilação, siga estas etapas:

  1. Na janela Project à esquerda, clique no menu suspenso e selecione a visualização Project.
  2. Na pasta de módulo adequada, clique com o botão direito na pasta src e clique em New > Directory.
  3. Para o nome de diretório, insira "androidTestVariantName." Por exemplo, se você tiver uma variação de compilação denominada "MyFlavor", o nome do diretório deverá ser "androidTestMyFlavor." Clique em OK.
  4. Clique com o botão direito no novo diretório e clique em New > Directory.
  5. Insira "java" como nome do diretório e clique em OK.

Agora você pode adicionar testes a esse novo conjunto de origem seguindo as etapas acima para adicionar um novo teste. Quando você chegar à caixa de diálogo Choose Destination Directory, selecione o novo conjunto de origem de teste da variação.

Os testes instrumentados no conjunto de origem src/androidTest/ são compartilhados por todas as variações de compilação. Na compilação de um APK de teste para a variação "MyFlavor" do aplicativo, o Gradle combina os conjuntos de origem src/androidTest/ e src/androidTestMyFlavor/ .

Por exemplo, a tabela a seguir mostra como os arquivos de teste de instrumentação devem residir nos conjuntos de origem correspondentes aos conjuntos de origem do código do aplicativo.

Caminho para a classe do aplicativo Caminho para a classe de teste de instrumentação correspondente
src/main/java/Foo.java src/androidTest/java/AndroidFooTest.java
src/myFlavor/java/Foo.java src/androidTestMyFlavor/java/AndroidFooTest.java

Da mesma forma que nos conjuntos de origem do aplicativo, a compilação do Gradle mescla e modifica arquivos de conjuntos de origem de teste diferentes. Neste caso, o arquivo AndroidFooTest.java no conjunto de origem "androidTestMyFlavor" modifica a versão no conjunto de origem "androidTest". Para obter mais informações sobre mescla de conjuntos de origem, consulte Configure sua compilação.

Outro motivo pelo qual você deve usar variações de compilação para os conjuntos de origem do aplicativo e de teste é a criação de testes herméticos por meio de dependências simuladas. Ou seja, você pode criar uma variação de produto para o aplicativo que contém implementações falsas de dependências (como solicitações de rede ou dados de sensor do dispositivo que normalmente são instáveis) e adicionar um conjunto de origem de teste simulado correspondente. Para obter mais informações, consulte a postagem do blog sobre o uso de variações de produto para testes herméticos.

Executar um teste

Para executar um teste, faça o seguinte:

  1. Verifique se o projeto está sincronizado com o Gradle clicando em Sync Project na barra de ferramentas.
  2. Execute o teste de uma das seguintes formas:
    • Na janela Project, clique com o botão direito em um teste e clique em Run .
    • No editor de código, clique com o botão direito em uma classe ou método no arquivo de teste e clique em Run para testar todos os métodos da classe.
    • Para executar todos os testes, clique com o botão direito no diretório de teste e clique em Run tests .

Por padrão, o teste é executado usando a configuração de execução padrão do Android Studio. Se você quiser alterar algumas configurações de execução, como a opções de executor e implantação de instrumentação, pode editar a configuração de execução na caixa de diálogo Run/Debug Configurations (clique em Run > Edit Configurations).

Alterar o tipo de compilação de teste

Por padrão, todos os testes são executados com o tipo de compilação de depuração. Para alterar isso para outro tipo de compilação, use a propriedade testBuildType no arquivo build.gradle do módulo. Por exemplo: se você quiser executar os testes com o tipo de compilação "preparação", edite o arquivo como mostrado no snippet a seguir.

android {
    ...
    testBuildType "staging"
}
This site uses cookies to store your preferences for site-specific language and display options.

Get the latest Android developer news and tips that will help you find success on Google Play.

* Required Fields

Hooray!

Follow Google Developers on WeChat

Browse this site in ?

You requested a page in , but your language preference for this site is .

Would you like to change your language preference and browse this site in ? If you want to change your language preference later, use the language menu at the bottom of each page.

This class requires API level or higher

This doc is hidden because your selected API level for the documentation is . You can change the documentation API level with the selector above the left navigation.

For more information about specifying the API level your app requires, read Supporting Different Platform Versions.

Take a short survey?
Help us improve the Android developer experience.
(Sep 2017 survey)