Segmentar um exemplo de app

Essa categoria de teste de instrumentação não é muito diferente daquelas que são destinadas aos aplicativos Android normais. Vale ressaltar que o aplicativo de teste que incluiu a instrumentação precisa ser assinado com o mesmo certificado do aplicativo de destino.

Este guia pressupõe que você já tenha algum conhecimento no fluxo de trabalho da árvore de origem da plataforma. Caso contrário, consulte os requisitos. O exemplo abordado aqui é escrever um novo teste de instrumentação com o pacote alvo definido no próprio pacote do aplicativo de teste. Se você não estiver familiarizado com o conceito, leia a Introdução aos testes de plataforma.

Este guia usa o seguinte teste como exemplo:

• frameworks/base/packages/Shell/tests

É recomendável navegar pelo código primeiro para ter uma ideia aproximada antes de continuar.

Escolher um local de origem

Como o teste de instrumentação será destinado a um aplicativo, a convenção é colocar o código-fonte do teste em um diretório tests na raiz do diretório de origem do componente na árvore de origem da plataforma.

Confira mais discussões sobre a localização da origem no exemplo completo de testes de autoinstrumentação.

Arquivo de manifesto

Assim como um aplicativo normal, cada módulo de teste de instrumentação precisa de um arquivo de manifesto. Se você nomear o arquivo como AndroidManifest.xml e fornecer a ele Android.mk para o módulo de teste, ele será incluído automaticamente pelo arquivo de make principal BUILD_PACKAGE.

Antes de continuar, é altamente recomendável consultar a Visão geral do manifesto do app primeiro.

Isso mostra uma visão geral dos componentes básicos de um arquivo de manifesto e as funcionalidades deles.

A versão mais recente do arquivo de manifesto para a mudança de exemplo do Gerrit pode ser acessada em: https://android.googlesource.com/platform/frameworks/base/+/main/packages/Shell/tests/AndroidManifest.xml

Um snapshot está incluído aqui para sua conveniência:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.android.shell.tests">

    <application>
        <uses-library android:name="android.test.runner" />

        <activity
            android:name="com.android.shell.ActionSendMultipleConsumerActivity"
            android:label="ActionSendMultipleConsumer"
            android:theme="@android:style/Theme.NoDisplay"
            android:noHistory="true"
            android:excludeFromRecents="true">
            <intent-filter>
                <action android:name="android.intent.action.SEND_MULTIPLE" />
                <category android:name="android.intent.category.DEFAULT" />
                <data android:mimeType="*/*" />
            </intent-filter>
        </activity>
    </application>

    <instrumentation android:name="android.support.test.runner.AndroidJUnitRunner"
        android:targetPackage="com.android.shell"
        android:label="Tests for Shell" />

</manifest>

Algumas observações selecionadas sobre o arquivo de manifesto:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.android.shell.tests">

O atributo package é o nome do pacote do aplicativo: é o identificador exclusivo que o framework do aplicativo Android usa para identificar um aplicativo (ou, neste contexto, o aplicativo de teste). Cada usuário no sistema só pode instalar um aplicativo com esse nome de pacote.

Como este é um pacote de aplicativo de teste, independente do pacote de aplicativo em teste, é necessário usar um nome de pacote diferente: uma convenção comum é adicionar um sufixo .test.

Além disso, esse atributo package é o mesmo que ComponentName#getPackageName() retorna e também o mesmo que você usaria para interagir com vários subcomandos pm por adb shell.

Além disso, embora o nome do pacote normalmente tenha o mesmo estilo que um nome de pacote Java, ele tem poucas coisas em comum com ele. Em outras palavras, o pacote do aplicativo (ou teste) pode conter classes com qualquer nome de pacote. Por outro lado, você pode optar pela simplicidade e ter o nome do pacote Java de nível superior no aplicativo ou teste idêntico ao nome do pacote do aplicativo.

<uses-library android:name="android.test.runner" />

Isso é necessário para todos os testes de instrumentação, já que as classes relacionadas são empacotadas em um arquivo de biblioteca JAR de framework separado. Portanto, são necessárias entradas de caminho de classe adicionais quando o pacote de teste é invocado pelo framework do aplicativo.

android:targetPackage="com.android.shell"

Isso define o pacote de destino da instrumentação como com.android.shell. Quando a instrumentação é invocada pelo comando am instrument, o framework reinicia o processo com.android.shell e injeta o código de instrumentação no processo para execução do teste. Isso também significa que o código de teste terá acesso a todas as instâncias de classe em execução no aplicativo em teste e poderá manipular o estado dependendo dos hooks de teste expostos.

Arquivo de configuração simples

Cada novo módulo de teste precisa ter um arquivo de configuração para direcionar o sistema de build com metadados do módulo, dependências de tempo de compilação e instruções de empacotamento. Na maioria dos casos, a opção de arquivo Blueprint baseada em Soong é suficiente. Consulte Configuração de teste simples para mais detalhes.

Arquivo de configuração complexo

Importante: as instruções desta seção são necessárias apenas para testes do CTS ou aqueles que exigem uma configuração especial, como desativar o Bluetooth ou coletar dados de amostra. Todos os outros casos podem ser cobertos pela Configuração de teste simples. Consulte a Configuração de teste complexo para mais detalhes aplicáveis a esta seção.

Para testes mais complexos, também é necessário escrever um arquivo de configuração de teste para o harness de teste do Android, Trade Federation.

A configuração de teste pode especificar opções especiais de configuração do dispositivo e argumentos padrão para fornecer a classe de teste.

A versão mais recente do arquivo de configuração da mudança de exemplo do Gerrit pode ser acessada em: frameworks/base/packages/Shell/tests/AndroidTest.xml

Por conveniência, incluímos um snapshot aqui:

<configuration description="Runs Tests for Shell.">
    <target_preparer class="com.android.tradefed.targetprep.TestAppInstallSetup">
        <option name="test-file-name" value="ShellTests.apk" />
    </target_preparer>

    <option name="test-suite-tag" value="apct" />
    <option name="test-tag" value="ShellTests" />
    <test class="com.android.tradefed.testtype.AndroidJUnitTest" >
        <option name="package" value="com.android.shell.tests" />
        <option name="runner" value="android.support.test.runner.AndroidJUnitRunner" />
    </test>
</configuration>

Algumas observações selecionadas no arquivo de configuração do teste:

<target_preparer class="com.android.tradefed.targetprep.TestAppInstallSetup">
  <option name="test-file-name" value="ShellTests.apk"/>
</target_preparer>

Isso informa à Trade Federation para instalar o ShellTests.apk no dispositivo de destino usando um target_preparer especificado. Há muitos preparadores de destino disponíveis para desenvolvedores no Trade Federation, que podem ser usados para garantir que o dispositivo seja configurado corretamente antes da execução do teste.

<test class="com.android.tradefed.testtype.AndroidJUnitTest">
  <option name="package" value="com.android.shell.tests"/>
  <option name="runner" value="android.support.test.runner.AndroidJUnitRunner"/>
</test>

Isso especifica a classe de teste da Trade Federation a ser usada para executar o teste e transmite o pacote no dispositivo a ser executado e o framework do executor de testes, que é JUnit nesse caso.

Confira mais informações em Configurações do módulo de teste.

Recursos do JUnit4

O uso da biblioteca android-support-test como executor de testes permite a adoção de novas classes de teste no estilo JUnit4, e a mudança de exemplo do Gerrit contém um uso muito básico dos recursos.

O código-fonte mais recente da amostra de mudança do Gerrit pode ser acessado em: frameworks/base/packages/Shell/tests/src/com/android/shell/BugreportReceiverTest.java (em inglês)

Embora os padrões de teste geralmente sejam específicos para equipes de componentes, há alguns padrões de uso úteis.

@SmallTest
@RunWith(AndroidJUnit4.class)
public final class FeatureFactoryImplTest {

Uma diferença significativa no JUnit4 é que os testes não precisam mais ser herdados de uma classe de teste base comum. Em vez disso, você escreve os testes em classes Java simples e usa anotações para indicar determinadas configurações e restrições de teste. Neste exemplo, estamos instruindo que essa classe precisa ser executada como um teste Android JUnit4.

A anotação @SmallTest especificou um tamanho de teste para toda a classe de teste: todos os métodos de teste adicionados a essa classe de teste herdam essa anotação de tamanho de teste. Configuração da classe de pré-teste, desmontagem pós-teste e desmontagem pós-teste: semelhante aos métodos setUp e tearDown no JUnit4. A anotação Test é usada para anotar o teste real.

Importante: os métodos de teste são anotados com a anotação @Test. Para que os testes sejam executados pelo APCT, eles precisam ser anotados com tamanhos de teste. Essa anotação pode ser aplicada no escopo do método ou da classe.

    @Before
    public void setup() {
    ...
    @Test
    public void testGetProvider_shouldCacheProvider() {
    ...

A anotação @Before é usada em métodos pelo JUnit4 para realizar a configuração pré-teste. Embora não seja usado neste exemplo, também há @After para a desmontagem pós-teste. Da mesma forma, as anotações @BeforeClass e @AfterClass podem ser usadas em métodos pelo JUnit4 para realizar a configuração antes de executar todos os testes em uma classe de teste e desmontar depois. Os métodos de configuração e desmontagem do escopo de classe precisam ser estáticos.

Quanto aos métodos de teste, ao contrário da versão anterior do JUnit, eles não precisam mais iniciar o nome do método com test. Em vez disso, cada um deles precisa ser anotado com @Test. Como de costume, os métodos de teste precisam ser públicos, declarar nenhum valor de retorno, não receber parâmetros e podem gerar exceções.

        Context context = InstrumentationRegistry.getTargetContext();

Como os testes do JUnit4 não precisam mais de uma classe base comum, não é mais necessário receber instâncias de Context usando getContext() ou getTargetContext() usando métodos de classe base. Em vez disso, o novo executor de teste os gerencia usando InstrumentationRegistry, onde a configuração contextual e ambiental criada pelo framework de instrumentação é armazenada. Com essa classe, você também pode chamar:

• getInstrumentation(): a instância da classe Instrumentation
• getArguments(): os argumentos da linha de comando transmitidos para am instrument por meio de -e <key> <value>

Criar e testar localmente

Para os casos de uso mais comuns, use o Atest.

Para casos mais complexos que exigem uma personalização mais pesada, siga as instruções de instrumentação.