Testar o código da plataforma com o atest

O Android Studio para plataforma (ASfP) se integra ao atest e aos módulos de teste do Soong para que você possa executar e depurar testes de plataforma na sua máquina host Linux, no dispositivo conectado ou no dispositivo virtual Cuttlefish no ambiente de desenvolvimento integrado (IDE, na sigla em inglês).

Pré-requisitos

• Abra um projeto ASfP configurado com seu checkout do AOSP e a meta lunch.
• Para testes de dispositivos, conecte um dispositivo físico ou inicie um dispositivo virtual Cuttlefish executando um build correspondente.

Executar e depurar testes

É possível iniciar testes de plataforma e sessões de depuração em vários lugares do ASfP:

• Android.bp destinos de teste: abra um arquivo Android.bp e clique em Executar no gutter ao lado de qualquer módulo de teste (*_test ou *_test_host):
  • Executar: disponível para todos os tipos de módulos de teste do Soong (android_test, java_test_host, cc_test, rust_test, python_test, sh_test e android_robolectric_test).
  • Depuração: disponível para módulos android_test (anexados com o depurador Java usando atest --wait-for-debugger) e módulos de teste em C++ ou Rust (cc_test, cc_test_host, rust_test e rust_test_host, iniciados no depurador LLDB integrado do ASfP).
• Ícones do gutter do arquivo de origem: clique em Executar ao lado de uma classe de teste ou um método @Test no código-fonte para executar ou depurar esse teste específico.
• Menu de contexto com clique direito: clique com o botão direito do mouse em um arquivo de teste, classe, método ou módulo Android.bp e selecione Executar ou Depurar.
• Agente integrado (IA no Android Studio): na janela de ferramentas Agente, o agente integrado pode executar destinos atest para verificar as mudanças depois de editar o código.
• Terminal integrado: abra View > Janelas de Ferramentas > Terminal para executar comandos atest diretamente.

Configuração e depuração de testes inteligentes

Quando você inicia um teste na margem ou no menu de contexto, o ASfP cria e configura uma configuração de execução do Soong Test usando seu gráfico de módulo Android.bp.

Depurar destinos android_test Java e Kotlin

Clique no ícone de gutter ao lado de um módulo android_test em Android.bp ou ao lado de uma classe JUnit Java ou Kotlin ou um método @Test e selecione Depurar '<TestName>'. Em um gutter de arquivo de origem, o ASfP escolhe o módulo android_test de inclusão mais próximo cujo srcs inclui o arquivo e nomeia a configuração <module>, <module>:<SimpleClass> ou <module>:<SimpleClass>#<method>.

O ASfP executa atest com --wait-for-debugger, lê o atributo package de destino do AndroidManifest.xml do módulo, aguarda esse processo no dispositivo conectado e anexa o depurador Java.

Depurar destinos cc_test e rust_test no LLDB

Para depurar um módulo de teste em C++ ou Rust (cc_test, cc_test_host, rust_test ou rust_test_host), clique no ícone da margem Android.bp e selecione Depurar '<TestName>'. O ASfP inicia o binário de teste compilado no depurador LLDB integrado em vez de executá-lo pelo atest.

Configurar a configuração de execução do teste do Soong

Abra Run > Edit Configurations e selecione uma configuração de Soong Test para personalizar como os testes são criados, implantados e iniciados:

• Preenchimento automático de módulos e navegação Android.bp: o campo Módulo é preenchido automaticamente com base nos módulos de teste Soong indexados no seu projeto. Clique em Acessar Android.bp ao lado do campo para acessar a declaração do módulo em Android.bp.
• Executar em: dispositivo ou host (incluindo host_supported: true): o ASfP avalia a regra do módulo e a cadeia transitiva defaults (host_supported, device_supported, enabled, target.android.enabled e target.host.enabled):
  • Testes de destino duplo (cc_test e rust_test com host_supported: true): os botões de opção Dispositivo e Host estão disponíveis (o padrão é Dispositivo). Dispositivo e Host mantêm modelos de depurador LLDB independentes. A troca de Executar em entre Dispositivo e Host alterna entre a configuração do dispositivo remoto lldb-server e a configuração binária do host local preservando as personalizações feitas em cada destino.
  • Testes de destino único: se um teste em C++ ou Rust for criado apenas para um ambiente (como um cc_test somente para dispositivos ou um cc_test_host ou rust_test_host somente para host), o ASfP vai selecionar o destino compatível e desativar o botão de opção incompatível com uma dica explicativa: "<module> (<ruleType>) doesn't build for the host or device.".
• Tarefas antes do lançamento (criar módulo de teste nativo e implantar com atest): toda configuração de Soong Test inclui duas tarefas de Antes do lançamento por padrão:
  • Criar módulo de teste nativo: cria <module>-target (para Dispositivo) ou <module>-host (para Host) antes de iniciar o LLDB.
  • Implantação com atest: ao depurar no Dispositivo, executa atest <module> --collect-tests-only --disable-teardown -it -s <serial> -- --abi <abi> para que o Tradefed envie dependências de teste e execute preparadores de destino antes que o LLDB inicie o binário. Mantenha o ponteiro sobre o chip Implantar com atest para visualizar o comando atest exato. Para uma iteração mais rápida quando as dependências já estão no dispositivo, remova Implantar com atest para que o ASfP envie apenas o binário de teste diretamente. Quando você seleciona Executar em: host, o ASfP pula automaticamente Implantar com atest.
• Modificar opções e depurador (cards de opções do LLDB): use Modificar opções para adicionar campos de configuração opcionais:
  • Argumentos do programa (somente testes de sistema operacional, C++ e Rust): argumentos extras transmitidos diretamente ao binário cc_test ou rust_test após o filtro --gtest_filter ou libtest durante a depuração.
  • Argumentos atest (Test): flags extras transmitidas para atest ao executar o teste ou ao preparar um dispositivo com Implantar com atest.
  • Depurador (somente testes em C++ e Rust): mostrado quando Módulo é um destino cc_test* ou rust_test*. Ative/desative os cards Opções do LLDB (como Parar na entrada, Armazenar símbolos em cache entre sessões, Carregar símbolos sob demanda ou Com visualizadores do Rust para testes do Rust), clique em Redefinir para os padrões para redefinir o modelo ativo Dispositivo ou Host ou adicione Diretórios de símbolos, Comandos de inicialização, pré-execução, pós-execução ou saída e JSON de inicialização (Configurações do DAP) em Modificar opções > Depurador.

Ver os resultados dos testes

O progresso da execução do teste, o status de aprovação ou falha, os rastreamentos de pilha e os registros do dispositivo aparecem em tempo real na janela de ferramentas Executar ou Depurar no ASfP.

Dicas para testes

• Executar testes direcionados: teste métodos individuais no gutter do editor sem executar um conjunto de testes inteiro.
• Use snapshots do Cuttlefish: ao executar testes de dispositivo em dispositivos virtuais do Cuttlefish, use snapshots para restaurar um estado limpo do dispositivo entre as execuções.
• Inspecionar registros de build do Soong: se um teste não for compilado antes da execução, confira a janela de ferramentas Soong para diagnósticos do compilador.