O que é cobertura de código e como você a mede?

O que é cobertura de código e como você a mede?

Fui perguntado sobre nossa cobertura de código de teste de automação. Parece que, fora das ferramentas automatizadas, é mais arte do que ciência. Existem exemplos reais de como usar a cobertura de código?

A cobertura de código é uma medida de quantas linhas / blocos / arcos do seu código são executados enquanto os testes automatizados estão em execução.

A cobertura do código é coletada usando uma ferramenta especializada para instrumentar os binários para adicionar chamadas de rastreamento e executar um conjunto completo de testes automatizados no produto instrumentado. Uma boa ferramenta fornecerá não apenas a porcentagem do código que é executado, mas também permitirá que você faça uma busca detalhada nos dados e veja exatamente quais linhas de código foram executadas durante um teste específico.

Nossa equipe usa o Magellan - um conjunto interno de ferramentas de cobertura de código. Se você é uma loja do .NET, o Visual Studio integrou ferramentas para coletar cobertura de código. Você também pode rolar algumas ferramentas personalizadas, como este artigo descreve.

Se você é uma loja de C ++, a Intel possui algumas ferramentas executadas para Windows e Linux, embora eu não as tenha usado. Também ouvi dizer que existe a ferramenta gcov para o GCC, mas não sei nada sobre isso e não posso fornecer um link para você.

Quanto à forma como a usamos - a cobertura do código é um dos critérios de saída para cada etapa. Na verdade, temos três métricas de cobertura de código - cobertura de testes de unidade (da equipe de desenvolvimento), testes de cenário (da equipe de teste) e cobertura combinada.

BTW, embora a cobertura do código seja uma boa métrica de quantos testes você está fazendo, não é necessariamente uma boa métrica de quão bem você está testando seu produto. Existem outras métricas que você deve usar junto com a cobertura do código para garantir a qualidade.

A cobertura do código basicamente testa se o seu código é coberto por testes. Portanto, se você tiver 90% de cobertura de código, isso significa que há 10% de código que não é coberto nos testes. Eu sei que você pode estar pensando que 90% do código é coberto, mas você precisa olhar de um ângulo diferente. O que está impedindo você de obter 100% de cobertura de código?

Um bom exemplo será este:

if(customer.IsOldCustomer()) 
{
}
else 
{
}

Agora, no código acima, existem dois caminhos / ramificações. Se você estiver sempre pressionando a ramificação "SIM", não estará cobrindo a parte else e ela será mostrada nos resultados da Cobertura de código. Isso é bom porque agora você sabe o que não é coberto e pode escrever um teste para cobrir a outra parte. Se não havia cobertura de código, você está sentado em uma bomba-relógio para explodir.

O NCover é uma boa ferramenta para medir a cobertura do código.

Lembre-se, ter "100% de cobertura de código" não significa que tudo é testado completamente - enquanto isso significa que toda linha de código é testada, não significa que eles são testados em todas as situações (comuns).

Eu usaria cobertura de código para destacar bits de código nos quais provavelmente deveria escrever testes. Por exemplo, se qualquer ferramenta de cobertura de código mostrar que myImportantFunction () não é executada durante a execução dos testes de unidade atuais, eles provavelmente deverão ser aprimorados.

Basicamente, 100% de cobertura de código não significa que seu código seja perfeito. Use-o como um guia para escrever testes mais abrangentes (unitários).

Complementando alguns pontos para muitas das respostas anteriores:

A cobertura do código significa quão bem o seu conjunto de testes está cobrindo o seu código-fonte. isto é, até que ponto o código fonte é coberto pelo conjunto de casos de teste.

Como mencionado nas respostas acima, existem vários critérios de cobertura, como caminhos, condições, funções, declarações, etc. Mas critérios adicionais a serem cobertos são

1. Cobertura de condição: todas as expressões booleanas a serem avaliadas como verdadeiras e falsas.
2. Cobertura de decisão: não apenas expressões booleanas a serem avaliadas como verdadeiras e falsas uma vez, mas também para cobrir todo o corpo subsequente se-senão.
3. Cobertura de loop: significa que todo loop possível foi executado uma vez, mais de uma vez e zero tempo. Além disso, se assumirmos o limite máximo, se possível, teste os tempos limites máximos e, um a mais que os tempos limites máximos.
4. Cobertura de entrada e saída: teste para todas as chamadas possíveis e seu valor de retorno.
5. Cobertura do valor do parâmetro (PVC). Para verificar se todos os valores possíveis para um parâmetro foram testados. Por exemplo, uma string pode ser uma das seguintes: a) nula, b) vazia, c) espaço em branco (espaço, guias, nova linha), d) string válida, e) string inválida, f) string de byte único, g ) sequência de bytes duplos. Falha ao testar cada valor possível de parâmetro pode deixar um erro. Testar apenas um deles pode resultar em 100% de cobertura de código à medida que cada linha é coberta, mas como apenas uma das sete opções é testada, significa apenas 14,2% de cobertura do valor do parâmetro.
6. Cobertura de herança: no caso de origem orientada a objeto, ao retornar um objeto derivado referido pela classe base, a cobertura para avaliar, se o objeto irmão for retornado, deve ser testada.

Nota: A análise de código estático descobrirá se há algum código inacessível ou código suspenso, ou seja, código não coberto por nenhuma outra chamada de função. E também outra cobertura estática. Mesmo se a análise de código estático relatar que 100% do código está coberto, ele não fornecerá relatórios sobre o seu conjunto de testes se toda a cobertura possível do código for testada.

A cobertura do código foi explicada bem nas respostas anteriores. Portanto, essa é mais uma resposta para a segunda parte da pergunta.

Usamos três ferramentas para determinar a cobertura do código.

1. JTest - uma ferramenta proprietária criada sobre o JUnit. (Ele também gera testes de unidade.)
2. Cobertura - uma ferramenta de cobertura de código-fonte aberto que pode ser facilmente acoplada aos testes JUnit para gerar relatórios.
3. Emma - outra - essa que usamos para um propósito ligeiramente diferente do teste de unidade. Ele foi usado para gerar relatórios de cobertura quando o aplicativo da Web é acessado pelos usuários finais. Isso, juntamente com as ferramentas de teste da Web (exemplo: Canoo), pode fornecer relatórios de cobertura muito úteis, informando quanto código é coberto durante o uso típico do usuário final.

Usamos essas ferramentas para

• Revise que os desenvolvedores escreveram bons testes de unidade
• Certifique-se de que todo o código seja percorrido durante o teste da caixa preta

A cobertura do código é simplesmente uma medida do código testado. Há vários critérios de cobertura que podem ser medidos, mas geralmente são os vários caminhos, condições, funções e instruções de um programa que compõem a cobertura total. A métrica de cobertura de código é apenas uma porcentagem de testes que executam cada um desses critérios de cobertura.

No que diz respeito ao acompanhamento da cobertura dos testes de unidade em meus projetos, uso ferramentas de análise de código estático para acompanhar.

Para Perl, existe o excelente módulo Devel :: Cover , que eu uso regularmente nos meus módulos.

Se a compilação e instalação são gerenciadas pelo Module :: Build, você pode simplesmente executar ./Build testcoverpara obter um bom site HTML que informe a cobertura por sub, linha e condição, com cores agradáveis, facilitando a visualização de qual caminho de código não foi coberto.

Nas respostas anteriores, a cobertura do código foi bem explicada. Estou apenas adicionando algum conhecimento relacionado às ferramentas, se você estiver trabalhando em plataformas iOSe OSX, o Xcode fornece a facilidade para testar e monitorar a cobertura do código.

Links de referência:

https://developer.apple.com/library/archive/documentation/DeveloperTools/Conceptual/testing_with_xcode/chapters/07-code_coverage.html

https://medium.com/zendesk-engineering/code-coverage-and-xcode-6b2fb8756a51

Ambos são links úteis para aprender e explorar a cobertura do código com o Xcode.

Para PHP, você deve dar uma olhada no Github de Sebastian Bergmann

Fornece funcionalidade de coleta, processamento e renderização para informações de cobertura de código PHP.

https://github.com/sebastianbergmann/php-code-coverage