Criar um executor de teste IRemoteTest fragmentado

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

Ao programar um executor de testes, é importante pensar na escalonabilidade. Perguntar "Se meu executor tivesse que executar 200 mil casos de teste" quanto tempo isso levaria?

O fragmentação é uma das respostas disponíveis na Trade Federation. É necessário dividir todos os testes necessários para o executor em vários blocos que podem ser executados em paralelo.

Esta página descreve como tornar o executor fragmentável para o Tradefed.

Interface a ser implementada

A interface mais importante a ser implementada para ser considerada fragmentável O TF é IShardableTest, que contém dois métodos: split(int numShard) e split().

Se a fragmentação depender do número de fragmentos solicitados, precisa implementar split(int numShard). Caso contrário, implemente split().

Quando um comando de teste do TF é executado com parâmetros de fragmentação --shard-count e --shard-index, o TF itera por todos os IRemoteTest para procurar aqueles que implementam IShardableTest. Se encontrado, ele vai chamar split para receber um novo objeto IRemoteTest para executar um subconjunto de casos de teste para um determinado no fragmento.

O que preciso saber sobre a implementação de divisão?

• O corredor pode fazer a fragmentação apenas sob algumas condições; Nesse caso, retorne null. sem fragmentação.
• Tente dividir o que quiser: divida o executor em uma unidade de de uma execução que faça sentido para ele. Depende do seu corredor. Por exemplo: HostTest é dividido no nível da classe, cada classe de teste é colocada em um fragmento separado.
• Se fizer sentido, adicione algumas opções para controlar um pouco a fragmentação. Por exemplo, AndroidJUnitTest tem um ajur-max-shard para especificar o número máximo de fragmentos em que ele pode ser dividido, independentemente do número solicitado.

Exemplo detalhado de implementação

Confira um exemplo de snippet de código que implementa IShardableTest. de referência. O código completo está disponível em (https://android.googlesource.com/platform/tools/tradefederation/+/refs/heads/main/test_framework/com/android/tradefed/testtype/localizedInstrumentationsTest.java)

/**
 * Runs all instrumentation found on current device.
 */
@OptionClass(alias = "installed-instrumentation")
public class InstalledInstrumentationsTest
        implements IDeviceTest, IResumableTest, IShardableTest {
    ...

    /** {@inheritDoc} */
    @Override
    public Collection<IRemoteTest> split(int shardCountHint) {
        if (shardCountHint > 1) {
            Collection<IRemoteTest> shards = new ArrayList<>(shardCountHint);
            for (int index = 0; index < shardCountHint; index++) {
                shards.add(getTestShard(shardCountHint, index));
            }
            return shards;
        }
        // Nothing to shard
        return null;
    }

    private IRemoteTest getTestShard(int shardCount, int shardIndex) {
        InstalledInstrumentationsTest shard = new InstalledInstrumentationsTest();
        try {
            OptionCopier.copyOptions(this, shard);
        } catch (ConfigurationException e) {
            CLog.e("failed to copy instrumentation options: %s", e.getMessage());
        }
        shard.mShardIndex = shardIndex;
        shard.mTotalShards = shardCount;
        return shard;
    }
    ...
}

Este exemplo apenas cria uma nova instância de si mesma e define o fragmento parâmetros a ela. No entanto, a lógica de divisão pode ser totalmente diferente teste para testar; e contanto que seja determinista e produza coletivamente subconjuntos exaustivos, tudo bem.

Independência

Os fragmentos precisam ser independentes. Dois fragmentos criados pela implementação de split no executor não podem ter dependências um do outro nem compartilhar recursos.

A divisão de fragmentos precisa ser determinística. Isso também é obrigatório, considerando que mesmas condições, o método split precisa sempre retornar exatamente a mesma lista de os fragmentos na mesma ordem.

OBSERVAÇÃO: como cada fragmento pode ser executado em diferentes instâncias do TF, é fundamental garantir que a lógica split gere subconjuntos mutuamente exclusivos e coletivamente exaustivos de maneira determinística.

Fragmentar um teste localmente

Para fragmentar um teste em um TF local, basta adicionar a opção --shard-count ao na linha de comando.

tf >run host --class com.android.tradefed.UnitTests --shard-count 3

Em seguida, o TF vai gerar comandos automaticamente para cada fragmento e executá-los.

tf >l i
Command Id  Exec Time  Device          State
3           0m:03      [null-device-2]  running stub on build 0 (shard 1 of 3)
3           0m:03      [null-device-1]  running stub on build 0 (shard 0 of 3)
3           0m:03      [null-device-3]  running stub on build 0 (shard 2 of 3)

Agregação do resultado do teste

Como o TF não faz nenhuma agregação de resultados de teste para invocações divididas, é necessário verificar se o serviço de relatórios oferece suporte a isso.