Use a cobertura de código para determinar quanto do código está sendo testado

Para determinar qual proporção do código do projeto está sendo testada por testes codificados, como testes de unidade, você pode usar o recurso de cobertura de código do Visual Studio. Para se proteger efetivamente contra bugs, os testes devem exercitar ou "cobrir" uma grande proporção de seu código.

A análise de cobertura de código é possível para código CLR (gerenciado) e não gerenciado (nativo). Há suporte para instrumentação estática e dinâmica. Para usar a cobertura de código em cenários de linha de comando, use vstest.console.exe ou a ferramenta Microsoft.CodeCoverage.Console, que é uma extensão para cobertura de dotnet, que também dá suporte ao código nativo.

A opção de cobertura de código está disponível no menu Teste quando você executa métodos de teste usando o Gerenciador de Testes. A tabela de resultados mostra o percentual do código executado em cada assembly, classe e procedimento. O editor de origem realça o código testado. Você pode exportar os resultados em formatos populares, como Cobertura.

Requisitos

O recurso de cobertura de código está disponível apenas no Visual Studio Enterprise Edition.

Nota

Para cobertura de código do .NET, como alternativa, você pode usar a ferramenta de linha de comando, dotnet-coverage.

Analisar a cobertura de código

1. No menu Teste, selecione Analisar Cobertura de Código para Todos os Testes.

   

   Dica

   Você também pode executar a cobertura de código na janela de ferramentas do Gerenciador de Testes.

2. Depois que os testes forem executados, para ver quais linhas foram executadas, escolha Mostrar Coloração de Cobertura de Código na janela Resultados da Cobertura de Código. Por padrão, o código coberto por testes é realçado em azul claro.

   

   Na lista suspensa para a opção Mostrar Coloração de Cobertura de Código, você pode selecionar se a coloração se aplica a linhas de código, glifos na margem esquerda ou ambos.

3. Para alterar as cores ou usar a face em negrito, escolha Ferramentas>Opções>Ambiente>Fontes e Cores>Mostrar configurações para: Editor de Texto. Em Exibir itens, ajuste as configurações para os itens de "Cobertura", por exemplo, Área Não Tocada de Cobertura.

   

4. Se os resultados mostrarem baixa cobertura, investigue quais partes do código não estão sendo exercidas e escreva mais testes para cobri-las. As equipes de desenvolvimento normalmente desejam uma cobertura de código de aproximadamente 80%. Em algumas situações, uma cobertura mais baixa é aceitável. Por exemplo, uma cobertura mais baixa é aceitável quando algum código é gerado a partir de um modelo padrão.

Dica

Para otimizar a cobertura de código:

• Desative a otimização do compilador.
• Se você estiver trabalhando com código não gerenciado (nativo), use uma versão de debug.
• Gere arquivos .pdb (símbolo) para cada assembly.

Se você não obtiver os resultados esperados, confira Solução de problemas da cobertura de código.

Não se esqueça de executar novamente a cobertura de código depois de atualizar seu código. Os resultados de cobertura e a coloração de código não são atualizados automaticamente depois que você modifica o código ou quando executa testes.

Dica

A partir do Visual Studio 2022 versão 17.2, você pode habilitar os recursos de cobertura de código mais recentes selecionando Ferramentas > Opções > Ambiente > Recursos de Visualização, depois selecionando Aprimoramentos na experiência de cobertura de código e reiniciando o Visual Studio.

Relatório em blocos ou linhas

A cobertura de código é contada em blocos. Um bloco é uma parte do código com exatamente um ponto de entrada e um de saída. Se o fluxo de controle do programa passar por um bloco durante uma execução de teste, esse bloco será contado como coberto. O número de vezes que o bloco é usado não afeta o resultado.

Você também pode ter os resultados exibidos para linhas escolhendo Adicionar/Remover Colunas no cabeçalho da tabela. Alguns usuários preferem uma contagem de linhas porque os percentuais correspondem mais de perto ao tamanho dos fragmentos que você vê no código-fonte. Um longo bloco de cálculo contaria como um único bloco, mesmo se ocupasse muitas linhas.

Dica

Uma linha de código pode conter mais de um bloco de código. Se esse for o caso e o teste utilizar todos os blocos de código na linha, essa linha será contada como uma única linha. Se alguns, mas nem todos os blocos de código na linha forem exercidos, ele será contado como uma linha parcial.

Visualizações de resultados da cobertura de código

A janela de Resultados de Cobertura de Código normalmente estrutura o relatório na hierarquia de projeto/classe/método. Você pode alterá-lo para mostrar a cobertura no nível de diretório/arquivo/método.

• Para exibir o Relatório de origem, selecione o ícone Configurar Exibições de Cobertura de Código na janela Resultados de Cobertura de Código. Em seguida, selecione Exibição de Código-Fonte na lista suspensa de Estilo de Relatório.

A janela Resultados da Cobertura de Código geralmente mostra o resultado da solução inteira. Os resultados podem ser filtrados para mostrar os resultados apenas para os arquivos que foram atualizados no branch atual.

• Para exibir o relatório do conjunto de alterações, selecione o ícone Configurar exibições de cobertura de código na janela Resultados da cobertura de Código. Em seguida, selecione Relatório do conjunto de alterações na lista suspensa Conteúdo do Relatório. Atualize o Repositório Ativo e o Branch Base para comparar com ele para fornecer o relatório de comparação.

Na caixa de pesquisa na janela Resultados da Cobertura de Código, há várias maneiras pelas quais o relatório pode ser filtrado.

• Para Pesquisar por nome (mostrar somente aqueles que correspondem à cadeia de caracteres de pesquisa na janela), insira a cadeia de caracteres de pesquisa na caixa de pesquisa.
• Para filtrar por tipo, digite o nome do tipo na caixa de pesquisa.
• Para Mostrar tudo, desmarque a caixa de pesquisa.
• Para Mostrar 100% totalmente coberto, insira "Coberto (%Linhas)":"100" na caixa de pesquisa.
• Para Mostrar (>0% && < 100%) parcialmente coberto, insira "Parcialmente Coberto (%Linhas)":"<##" substituindo o ## pelo percentual de cobertura.
• Para Mostrar 0% coberto, insira "Não Coberto (%Linhas)":"0" na caixa de pesquisa.

Gerenciar resultados da cobertura de código

A janela Resultados da Cobertura de Código geralmente mostra o resultado da execução mais recente. Os resultados variarão se você alterar seus dados de teste ou se executar apenas alguns de seus testes todas as vezes.

A janela Resultados da cobertura de código também pode ser usada para exibir os resultados anteriores ou os resultados obtidos em outros computadores.

Você pode mesclar os resultados de várias execuções, por exemplo, de execuções que usam dados de teste diferentes.

• Para exibir um conjunto de resultados anterior, selecione-o no menu suspenso. O menu mostra uma lista temporária que é apagada quando você abre uma nova solução.

• Para exibir os resultados de uma sessão anterior, escolha Importar Resultados, navegue até a pasta TestResults em sua solução e importe um arquivo .coverage.

  A coloração de cobertura pode estar incorreta se o código-fonte foi alterado desde a geração do arquivo .coverage.

• Para tornar os resultados legíveis como texto, escolha Exportar Resultados, selecione .xml para Salvar como tipo. Isso gera um arquivo de .xml legível, que você pode processar com outras ferramentas ou enviar facilmente por email. Você também pode selecionar formatos de exportação, como Cobertura.

• Para enviar resultados para outra pessoa, envie um arquivo .coverage ou um arquivo de .xml exportado. Em seguida, eles podem importar o arquivo. Se eles tiverem a mesma versão do código-fonte, poderão ver a coloração da cobertura.

Mesclar resultados de execuções diferentes

Em algumas situações, blocos diferentes em seu código serão usados dependendo dos dados de teste. Portanto, talvez você queira combinar os resultados de diferentes execuções de teste.

Por exemplo, suponhamos que, ao executar um teste com a entrada “2 ", você descobre que 50% de uma função específica está coberta. Quando você executa o teste uma segunda vez com a entrada "-2 ", vê na exibição de cores de cobertura que os outros 50% da função estão cobertos. Agora você mescla os resultados das duas execuções de testes, e a exibição do relatório e da coloração de cobertura mostra que 100% da função foi coberta.

Use Mesclar os resultados para fazê-lo. Você pode escolher qualquer combinação de execuções recentes ou resultados importados. Se você quiser combinar os resultados exportados, deve importá-los primeiro.

Use Exportar Resultados para salvar os resultados de uma operação de mesclagem.

Limitações na mesclagem

• Se você mesclar dados de cobertura de diferentes versões do código, os resultados serão mostrados separadamente, mas eles não serão combinados. Para obter resultados totalmente combinados, use o mesmo build do código, alterando apenas os dados de teste.

• Se você mesclar um arquivo de resultados que foi exportado e importado, poderá exibir apenas os resultados por linhas, não por blocos. Use o comando Adicionar/Remover Colunas para mostrar os dados de linha.

• Se você mesclar resultados de testes de um projeto de ASP.NET, os resultados dos testes separados serão exibidos, mas não combinados. Esse comportamento se aplica apenas aos artefatos do ASP.NET em si: os resultados dos outros assemblies serão combinados.

Excluir elementos dos resultados da cobertura de código

Talvez você queira excluir elementos específicos em seu código das pontuações de cobertura, por exemplo, se o código for gerado de um modelo de texto. Adicione o atributo System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute a qualquer dos seguintes elementos de código: classe, struct, método, propriedade, acessores de propriedade (setter ou getter), evento.

Dica

A exclusão de uma classe não exclui suas classes derivadas.

Por exemplo:

C#

using System.Diagnostics.CodeAnalysis;
...
public class ExampleClass1
{
    [ExcludeFromCodeCoverage]
    void ExampleMethod() {...}

    [ExcludeFromCodeCoverage] // exclude property
    int ExampleProperty1
    { get {...} set{...}}

    int ExampleProperty2
    {
        get
        {
            ...
        }
        [ExcludeFromCodeCoverage] // exclude setter
        set
        {
            ...
        }
    }

}
[ExcludeFromCodeCoverage]
class ExampleClass2 { ... }

VB

Imports System.Diagnostics.CodeAnalysis

Class ExampleClass1
    <ExcludeFromCodeCoverage()>
    Public Sub ExampleSub1()
        ...
    End Sub

    ' Exclude property
    < ExcludeFromCodeCoverage()>
    Property ExampleProperty1 As Integer
        ...
    End Property

    ' Exclude setter
    Property ExampleProperty2 As Integer
        Get
            ...
        End Get
        <ExcludeFromCodeCoverage()>
        Set(ByVal value As Integer)
            ...
        End Set
    End Property
End Class

<ExcludeFromCodeCoverage()>
Class ExampleClass2
...
End Class

C++

// A .cpp file compiled as managed (CLI) code.
using namespace System::Diagnostics::CodeAnalysis;
...
public ref class ExampleClass1
{
  public:
    [ExcludeFromCodeCoverage]
    void ExampleFunction1() { ... }

    [ExcludeFromCodeCoverage]
    property int ExampleProperty2 {...}

    property int ExampleProperty2 {
      int get() { ... }
     [ExcludeFromCodeCoverage]
      void set(int value) { ...  }
   }
}

[ExcludeFromCodeCoverage]
public ref class ExampleClass2
{ ... }

Excluir elementos no código C++ nativo

Para excluir elementos não gerenciados (nativos) no código C++:

#include <CodeCoverage\CodeCoverage.h>
...

// Exclusions must be compiled as unmanaged (native):
#pragma managed(push, off)

// Exclude a particular function:
ExcludeFromCodeCoverage(Exclusion1, L"MyNamespace::MyClass::MyFunction");

// Exclude all the functions in a particular class:
ExcludeFromCodeCoverage(Exclusion2, L"MyNamespace::MyClass2::*");

// Exclude all the functions generated from a particular template:
ExcludeFromCodeCoverage(Exclusion3, L"*::MyFunction<*>");

// Exclude all the code from a particular .cpp file:
ExcludeSourceFromCodeCoverage(Exclusion4, L"*\\unittest1.cpp");

// After setting exclusions, restore the previous managed/unmanaged state:
#pragma managed(pop)

Use as seguintes macros:

ExcludeFromCodeCoverage(ExclusionName, L"FunctionName");

ExcludeSourceFromCodeCoverage(ExclusionName, L"SourceFilePath");

• ExclusionName é qualquer nome exclusivo.

• FunctionName é um nome de função totalmente qualificado. Pode conter curingas. Por exemplo, para excluir todas as funções de uma classe, escreva MyNamespace::MyClass::*

• SourceFilePath é o caminho local ou UNC de um arquivo .cpp. Pode conter curingas. O exemplo a seguir exclui todos os arquivos em um diretório específico: \\MyComputer\Source\UnitTests\*.cpp

• #include <CodeCoverage\CodeCoverage.h>

• Faça chamadas para as macros de exclusão no namespace global, não dentro de nenhum namespace ou classe.

• Você pode colocar as exclusões no arquivo de código de teste de unidade ou no arquivo de código do aplicativo.

• As exclusões devem ser compiladas como código não gerenciado (nativo), definindo a opção do compilador ou usando #pragma managed(off).

Nota

Para excluir funções no código C++/CLI, aplique o atributo [System::Diagnostics::CodeAnalysis::ExcludeFromCodeCoverage] à função. Isso é o mesmo que para C#.

Incluir ou excluir elementos adicionais

A análise de cobertura de código é executada apenas em assemblies carregados e para os quais um arquivo .pdb está disponível no mesmo diretório do arquivo .dll ou .exe. Portanto, em algumas circunstâncias, você pode estender o conjunto de assemblies que é incluído obtendo cópias dos arquivos .pdb apropriados.

Você pode exercer mais controle sobre quais assemblies e elementos são selecionados para análise de cobertura de código escrevendo um arquivo .runsettings. Por exemplo, você pode excluir assemblies de tipos específicos sem precisar adicionar atributos às suas classes. Para obter mais informações, confira Personalizar a análise de cobertura de código.

Analisar a cobertura de código no Azure Pipelines

Quando você integra o código, seus testes são executados no servidor de integração, juntamente com os testes de outros membros da equipe. É útil analisar a cobertura de código no Azure Pipelines para obter o panorama mais recente e abrangente da cobertura no projeto inteiro. A cobertura de código no Azure Pipelines também inclui testes automatizados do sistema e outros testes codificados que você normalmente não executa nos computadores de desenvolvimento.

Analisar a cobertura de código na linha de comando

Para executar testes na linha de comando, use o utilitário vstest.console.exe. A cobertura de código é uma opção do utilitário vstest.console.exe invocado pela opção /EnableCodeCoverage.

1. Iniciar o Prompt de Comando do Desenvolvedor para o Visual Studio:

   No menu Iniciar do Windows, pesquise Developer Command Prompt for VS e selecione o resultado do aplicativo associado ao texto da pesquisa.

2. No prompt de comando, execute o seguinte comando:

   vstest.console.exe MyTestAssembly.dll /EnableCodeCoverage
   

   Dica

   Para o PowerShell do Desenvolvedor, o diretório inicial do shell é o Local do Projeto do Visual Studio. Substitua MyTestAssembly.dll pelo caminho e nome do arquivo de teste. Para obter mais informações, consulte as opções de linha de comando VSTest.Console.exe.

Solucionar problemas

Se os resultados da cobertura de código não forem exibidos, o artigo Solução de problemas de cobertura de código poderá ajudá-lo.

Conteúdo relacionado

• Personalizar a análise de cobertura de código
• Solução de problemas de cobertura de código
• Efetuar teste de unidade em seu código