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

Para determinar que proporção do código do projeto está sendo testada por testes codificados, como os 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 gerenciado (CLR) 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 a porcentagem 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.

Observação

Para cobertura de código .NET, 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 ambas.

3. Para alterar as cores ou usar a formatação em negrito, escolha Ferramentas>Opções>Ambiente>Fontes e Cores>Mostrar configurações de: 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 utilizadas e escreva mais testes para abrangê-las. As equipes de desenvolvimento normalmente desejam uma cobertura de código de aproximadamente 80%. Em algumas situações, uma cobertura menor é aceitável. Por exemplo, uma cobertura menor é aceitável onde um 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 um build de depuração.
• 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 serão atualizados automaticamente depois que você alterar o código ou executar os testes.

Dica

A partir do Visual Studio 2022 Atualização 2, você pode habilitar resultados de teste de cobertura de código mais rápidos selecionando o seguinte: Ferramentas > Opções > Ambiente > Versão prévia do recurso e Aprimoramentos de experiência de cobertura de código. Em seguida, reinicie o Visual Studio.

Relatórios 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 de saída. Se o fluxo de controle do programa passar por um bloco durante a execução de teste, esse bloco será considerado coberto. O número de vezes que o bloco é usado não afeta o resultado.

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

Dica

Uma linha de código pode conter mais de um bloco de código. Se for o caso e a execução de teste utilizar todos os blocos de código na linha, isso será contado como uma linha. Se alguns blocos de código, mas não todos, na linha forem utilizados, isso será contado como uma linha parcial.

Filtrar os resultados da cobertura de código

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, insira 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 podem variar se você alterar os dados de teste ou, se você executar apenas alguns dos testes cada vez.

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.

É possível mesclar os resultados de várias execuções, por exemplo, das 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 foi desmarcada quando você abrir uma nova solução.

• Para exibir os resultados de uma sessão anterior, escolha Importar Resultados da Cobertura de Código, navegue para a pasta TestResults na 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 da Cobertura de Código. Isso gera um arquivo .coveragexml legível que você pode processar com outras ferramentas ou enviar com facilidade por email. Você também pode selecionar formatos de exportação, como Cobertura.

• Para enviar os resultados para outra pessoa, envie um arquivo .coverage ou um arquivo .coveragexml exportado. A pessoa poderá importar o arquivo. Se ela tiver a mesma versão do código-fonte, poderá consultar a coloração de cobertura.

Mesclar resultados de execuções diferentes

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

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 Resultados da Cobertura de Código fazer isso. Você pode escolher qualquer combinação de execuções recentes ou resultados importados. Se você quiser combinar resultados exportados, importe-os primeiro.

Use Exportar Resultados da Cobertura de Código para salvar os resultados de uma operação de mesclagem.

Limitações na mesclagem

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

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

• Se você combinar os resultados dos testes de um projeto do 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

Você pode excluir elementos específicos em seu código das pontuações de cobertura, por exemplo, se o código é gerado a partir de um modelo de texto. Adicione o atributo System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute a qualquer um dos seguintes elementos de código: class, struct, method, property, property setter ou getter, event.

Dica

Excluir uma classe não exclui as 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 em código C++ Nativo

Para excluir os elementos não gerenciados (nativos) em 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 local ou o caminho 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>

• Coloque as chamadas para as macros de exclusão no namespace global, não em qualquer 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 criadas como o código não gerenciado (nativo), definindo a opção de compilador ou usando #pragma managed(off).

Observação

Para excluir funções em código C++/CLI, aplique o atributo [System::Diagnostics::CodeAnalysis::ExcludeFromCodeCoverage] à função. Esse é o mesmo para o 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 da cobertura de código escrevendo um arquivo .runsettings. Por exemplo, você pode excluir os 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ê faz check-in de seu código, os testes são executados no servidor de compilaçã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 os testes automatizados do sistema e outros testes codificados que normalmente não são executados 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 é a Localização do Projeto do Visual Studio. Substitua MyTestAssembly.dll pelo nome do arquivo de teste e caminho. Para obter mais informações, consulte Opções de linha de comando de 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
• Realizar teste de unidade do seu código