Desenvolvimento de CTS

Inicializar o cliente do Repo

Siga as instruções em Como fazer o download da origem para conferir e criar o código-fonte do Android. Ao emitir o comando repo init, especifique uma ramificação específica do CTS usando -b. Isso garante que suas mudanças de CTS sejam incluídas em versões subsequentes do CTS.

O exemplo de código a seguir mostra como usar repo init.

mkdir android11-tests-dev && cd android11-tests-dev && repo init -c -u https://android.googlesource.com/platform/manifest -b android11-tests-dev --use-superproject --partial-clone --partial-clone-exclude=platform/frameworks/base --clone-filter=blob:limit=10M && repo sync -c -j8

Criar e executar o CTS

Execute os comandos abaixo para criar o CTS e iniciar o console CTS interativo:

Observação:é possível usar aosp_x86_64 como alternativa a aosp_arm64.

Criar CTS (AOSP 14 ou anterior)

cd /path/to/android/root
source build/envsetup.sh
make cts -j32 TARGET_PRODUCT=aosp_arm64
cts-tradefed

Criar CTS (AOSP 15 ou mais recente)

cd /path/to/android/root
source build/envsetup.sh
make cts -j32 TARGET_PRODUCT=aosp_arm64 TARGET_RELEASE=target-release
cts-tradefed

Consulte a tabela a seguir para selecionar o valor target-release:

Filial	Versão de destino
android15-tests-dev	ap3a

No console do CTS, digite:

tf> run cts --plan CTS

Programar testes CTS

Para escrever um teste CTS com tecnologia de desenvolvedor (CTS-D), primeiro envie uma proposta de teste seguindo as instruções no processo de envio do CTS

.

Os testes do CTS usam o JUnit e as APIs de teste do Android. Revise o tutorial Testar seu app e os testes atuais no diretório cts/tests. Os testes do CTS seguem principalmente as mesmas convenções usadas em outros testes do Android.

O CTS é executado em muitos dispositivos de produção, portanto, os testes precisam seguir estas regras:

• Leve em conta os diferentes tamanhos, orientações e layouts de teclado.
• Use apenas métodos de API públicos. Em outras palavras, evite todas as classes, métodos e campos com a anotação hide.
• Evite usar layouts de visualização ou depender das dimensões de recursos que podem não estar em alguns dispositivos.
• Não dependa de privilégios raiz.

Adicionar anotação Java

Se o teste verificar um comportamento da API, anexe @ApiTest ao código de teste e liste todas as APIs envolvidas no campo apis. Use o formato adequado entre os seguintes exemplos:

API type	Formato da anotação	Observações
Método	android.example.ClassA#methodA	O caso de uso mais comum.
Método com valores de chave	android.example.ClassB#methodB(KeyA)	Use apenas quando o teste usar um método de API para validar um campo, como neste exemplo.
Campo	android.example.ClassC#FieldA	Use apenas quando o teste validar um campo de API diretamente, como neste exemplo.

Se o teste verificar um requisito do CDD, anote o ID do requisito (incluindo o ID da seção CDD e o ID do requisito) com @CddTest no código de teste do CTS, conforme mostrado no exemplo abaixo. Na mensagem de confirmação, mencione qual requisito do CDD é testado pelo seu teste, referindo-se aos IDs dos requisitos do CDD. Os IDs de requisitos do CDD são uma combinação do ID da seção e do ID do requisito, conectados por um caractere de barra (/), como em 7.3.1/C-1-1.

/**
* Verify Passpoint configuration management APIs for a Passpoint
* @throws Exception
*/
    @CddTest(requirement="7.4.2.3/C-1-1,C-2-1")
    public void testAddPasspointConfigWithUserCredential() throws Exception {
        if (!WifiFeature.isWifiSupported(getContext())) {
            // skip the test if WiFi is not supported
            return;
        }      testAddPasspointConfig(generatePasspointConfig(generateUserCredential()));
    }

Para o CTS Verifier, anexe a cada atividade no AndroidManifest.xml o ID de CDD relevante. Os formatos dos campos de valor são semelhantes aos formatos de anotações Java no CTS. Na mensagem de confirmação, mencione qual requisito de CDD é aplicado, referenciando o ID do requisito CDD.

  <activity>
    ......
    <!-- OPTIONAL: Add a meta data attribute to indicate CDD requirements. -->
    <meta-data android:name="cdd_test" android:value="7.4.1/C-4-1" />

    <!-- OPTIONAL: Add a meta data attribute to indicate APIs being tested. -->
    <meta-data android:name="api_test"
               android:value="com.example.MyClass#myMethod" />

    <!-- OPTIONAL: Add a metadata attribute to indicate the reason why the test doesn't enforce any CDD requirement but still useful in CTS-V. -->
    <meta-data android:name="non_compliance_test"
               android:value="detailed reasons" />
  </activity>

Na mensagem de confirmação

Mencione claramente por que o teste precisa ser adicionado e adicione links relevantes para suporte. Para testes CTS-D, inclua um link para a proposta de teste criada no Issue Tracker do Google como parte do processo de envio do CTS-D.

Criar um subplano

Por exemplo, é possível adicionar um arquivo SubPlan.xml em android-cts/subplans da seguinte maneira:

<?xml version="1.0" encoding="utf-8" standalone="no"?>
<SubPlan version="2.0">
<Entry include="CtsSystemIntentTestCases" />
<Entry include="CtsSystemUiHostTestCases" />
<Entry include="CtsSecurityHostTestCases android.security.cts.SELinuxHostTest#testAospFileContexts" />
<Entry include="CtsSecurityHostTestCases android.security.cts.SELinuxHostTest#testAospServiceContexts" />
</SubPlan>

Para executar o subplano:

run cts --subplan aSubPlan

O formato de entrada do subplano é:

Include a module name as follows:
<Entry include="MODULE_NAME" />

Include a package:
<Entry include="MODULE_NAME PACKAGE_NAME" />

Include a class:
<Entry include="MODULE_NAME PACKAGE_NAME.CLASS_NAME" />

Include an individual test:
<Entry include="MODULE_NAME PACKAGE_NAME.CLASS_NAME#TEST_NAME" />

Nomeação e localização do teste

A maioria dos casos de teste do CTS tem como alvo uma classe específica na API do Android. Esses testes têm nomes de pacote Java com um sufixo cts e nomes de classe com um sufixo Test. Cada caso de teste consiste em vários testes, em que cada teste geralmente exerce um método específico da classe que está sendo testada. Esses testes são organizados em uma estrutura de diretórios em que são agrupados em diferentes categorias, como "widgets" ou "visualizações".

Por exemplo, o teste do CTS para o pacote Java android.widget.TextView é android.widget.cts.TextViewTest com o nome do pacote Java como android.widget.cts e o nome da classe como TextViewTest.

• Nome do pacote Java
  O nome do pacote Java para os testes do CTS é o nome do pacote da classe que está sendo testada, seguido por .cts. No nosso exemplo, o nome do pacote seria android.widget.cts.
• Nome da classe
  O nome da classe para testes CTS é o nome da classe que está sendo testada com "Test" anexado. Por exemplo, se um teste tiver como alvo TextView, o nome da classe será TextViewTest.
• Nome do módulo (somente CTS v2)
  O CTS v2 organiza os testes por módulo. O nome do módulo geralmente é a segunda string do nome do pacote Java (no nosso exemplo, widget).

A estrutura de diretórios e o código de exemplo dependem se você está usando a CTS v1 ou a CTS v2.

CTS v1

Para o Android 6.0 ou versões anteriores, use o CTS v1. Para a CTS v1, o exemplo de código está em cts/tests/tests/example.

A estrutura de diretórios nos testes do CTS v1 é assim:

cts/
  tests/
    tests/
      package-name/
        Android.mk
        AndroidManifest.xml
        src/
          android/
            package-name/
              SampleDeviceActivity.java
              cts/
                SampleDeviceTest.java

CTS v2

Para o Android 7.0 ou mais recente, use o CTS v2. Para saber mais, consulte o teste de exemplo no Android Open Source Project (AOSP).

A estrutura de diretórios do CTS v2 é assim:

cts/
  tests/
    module-name/
      Android.mk
      AndroidManifest.xml
      src/
        android/
          package-name/
            SampleDeviceActivity.java
            cts/
              SampleDeviceTest.java

Novos pacotes de amostra

Ao adicionar novos testes, talvez não haja um diretório para colocar o teste. Nesses casos, é necessário criar o diretório e copiar os arquivos de amostra apropriados.

CTS v1

Se você estiver usando o CTS v1, consulte o exemplo em cts/tests/tests/example e crie um novo diretório. Além disso, adicione o nome do módulo do novo pacote de Android.mk para CTS_COVERAGE_TEST_CASE_LIST em cts/CtsTestCaseList.mk. O build/core/tasks/cts.mk usa esse makefile para combinar todos os testes e criar o pacote CTS final.

CTS v2

Use o teste de exemplo /cts/tests/sample/ para iniciar rapidamente o novo módulo de teste seguindo estas etapas:

1. Para criar o diretório de teste e copiar arquivos de amostra, execute:

   mkdir cts/tests/module-name && cp -r cts/tests/sample/* cts/tests/module-name

2. Navegue até cts/tests/module-name e substitua todas as instâncias de "[Ss]ample" pela convenção de nomenclatura recomendada acima.
3. Atualize SampleDeviceActivity para testar o recurso.
4. Atualize SampleDeviceTest para garantir que a atividade seja bem-sucedida ou registre seus erros.

Outros diretórios

Outros diretórios do Android, como assets, jni, libs e res, também podem ser adicionados. Para adicionar um código JNI, crie um diretório na raiz do projeto ao lado de src com o código nativo e um makefile Android.mk.

O makefile normalmente contém as seguintes configurações:

LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := libCtsSample_jni

# don't include this package in any target
LOCAL_MODULE_TAGS := optional
LOCAL_SRC_FILES := list of source code files
LOCAL_C_INCLUDES := $(JNI_H_INCLUDE)

# Tag this module as a cts test artifact
LOCAL_COMPATIBILITY_SUITE := cts
LOCAL_SHARED_LIBRARIES := libnativehelper
LOCAL_SDK_VERSION := current
include $(BUILD_SHARED_LIBRARY)

Arquivo Android.mk

Por fim, modifique o arquivo Android.mk na raiz do projeto para criar o código nativo e depender dele, conforme mostrado abaixo:

# All tests should include android.test.runner.
LOCAL_JAVA_LIBRARIES := android.test.runner

# Includes the jni code as a shared library
LOCAL_JNI_SHARED_LIBRARIES := libCtsSample_jni

# Include for InstrumentationCtsTestRunner
LOCAL_STATIC_JAVA_LIBRARIES := ctstestrunner...
LOCAL_SDK_VERSION := currentinclude $(BUILD_CTS_PACKAGE)

#Tells make to look in subdirectories for more make files to include
include $(call all-makefiles-under,$(LOCAL_PATH))

Corrigir ou remover testes

Além de adicionar novos testes, você pode corrigir ou remover testes anotados com BrokenTest ou KnownFailure.

Enviar as mudanças

Ao enviar patches CTS ou VTS no AOSP, escolha a ramificação de desenvolvimento com base nos níveis de API aos quais o patch se aplica.

• Para mudanças que se aplicam a vários níveis de API, primeiro desenvolva um patch em aosp/main e depois escolha o branch de teste mais upstream. Permita que a fusão automática mescle as mudanças downstream nas filiais de teste do AOSP. Consulte Programação de lançamentos e informações sobre ramificações para conferir a lista de ramificações e informações sobre o caminho de mesclagem automática.
• Para mudanças específicas de um nível de API específico, desenvolva ou escolha as mudanças para a ramificação de teste correta com DO NOT MERGE ou RESTRICT AUTOMERGE na mensagem de confirmação.

Siga o fluxo de trabalho de envio de patches para contribuir com mudanças no CTS. Um revisor será designado para analisar sua mudança.

Programação de lançamentos e informações sobre a ramificação

As versões do CTS seguem esta programação.

Observação:essa programação é provisória e será atualizada à medida que o CTS para a versão do Android for amadurecendo.

Versão	Nível da API	Filial	Frequência
15	35	android15-tests-dev	Trimestralmente
14	34	android14-tests-dev	Trimestralmente
13	33	android13-tests-dev	Trimestralmente
12L	32	android12L-tests-dev	Trimestralmente
12	31	android12-tests-dev	Trimestralmente

Observação:não há mais lançamentos planejados para as versões 4.2 a 11.

Datas importantes durante o lançamento

• Fim da primeira semana:congelamento do código. As mudanças mescladas na ramificação até o congelamento do código são consideradas para a próxima versão do CTS. Os envios para a ramificação após o congelamento do código ou após a escolha de um candidato para lançamento são considerados para a versão seguinte.
• Segunda ou terceira semana:o CTS é publicado no AOSP.

Fluxo de mesclagem automática

As ramificações de desenvolvimento do CTS foram configuradas para que as mudanças enviadas para cada ramificação sejam mescladas automaticamente às ramificações mais altas.

Para mudanças diretamente em um branch de desenvolvimento de teste do AOSP, o caminho de mesclagem automática é:
android11-tests-dev > android12-tests-dev > android12L-tests-dev > android13-tests-dev > android14-tests-dev > android15-tests-dev > aosp-main

Para mudanças apenas na próxima versão do Android, o caminho de mesclagem automática é:
aosp-main > <Internal git_main>.

Se uma lista de mudanças (CL) não for mesclada corretamente, o autor do patch vai receber um e-mail com instruções sobre como resolver o conflito. Na maioria dos casos, o autor do patch pode usar as instruções para pular a mesclagem automática do CL em conflito.

Se uma versão mais antiga exigir a mudança, o patch precisará ser escolhido da versão mais recente.