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

Para determinar qual proporção do código do seu 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 eficazmente contra bugs, seus testes devem exercitar ou "cobrir" uma grande proporção do seu código.

A análise de cobertura de código é possível para código gerenciado (CLR) e não gerenciado (nativo). A instrumentação estática e dinâmica é suportada. Para usar a cobertura de código em cenários de linha de comando, use vstest.console.exe ou ferramenta Microsoft.CodeCoverage.Console, que é uma extensão para de cobertura de dotnet que também oferece suporte a 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 código-fonte destaca o código testado. Você pode exportar os resultados em formatos populares, como Cobertura.

Requerimentos

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

Observação

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

Analise a cobertura do código

1. No menu de Teste , selecione Analisar cobertura de código de todos os testes.

   

   Dica

   Você também pode executar a cobertura de código na janela da ferramenta do Test Explorer.

2. Depois que os testes forem executados, para ver quais linhas foram executadas, escolha Mostrar de 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 da 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 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 "Cobertura", por exemplo, Área de Cobertura Não Tocada.

   

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 visam cerca de 80% cobertura de código. 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 do código:

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

Se não obtiver os resultados esperados, consulte Resolução de problemas de cobertura de código.

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

Dica

A partir da versão 17.2 do Visual Studio 2022, pode habilitar os recursos de cobertura de código mais recentes selecionando Ferramentas > Opções > Ambiente > Recursos de Pré-visualização, e em seguida, selecionando Melhorias na experiência de cobertura de códigoe reiniciando o Visual Studio.

Relatório em blocos ou linhas

A cobertura do código é contada em blocos. Bloco é uma parte do código com exatamente um ponto de entrada e 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ê pode também ter os resultados exibidos para as linhas, escolhendo Adicionar/Remover Colunas no cabeçalho da tabela. Alguns usuários preferem uma contagem de linhas porque as porcentagens correspondem mais de perto ao tamanho dos fragmentos que você vê no código-fonte. Um bloco longo de cálculo contaria como um único bloco, mesmo que ocupe muitas linhas.

Dica

Uma linha de código pode conter mais de um bloco de código. Se este for o caso, e a execução do teste exercitar todos os blocos de código nessa linha, isso conta como uma linha. Se alguns, mas não todos, os blocos de código na linha forem exercidos, ela será contada como uma linha parcial.

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

A janela Resultados da Cobertura de Código geralmente estrutura o relatório na hierarquia de projeto/classe/método. Você pode alterar isso para mostrar a cobertura no nível de diretório/arquivo/método.

• Para exibir oRelatório de origem, selecione o ícone Configurar Exibições de Cobertura de Código na janela Resultados da Cobertura de Código. Em seguida, selecione Vista do código-fonte na lista suspensa Estilo de relatório.

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

• Para visualizar oRelatório do conjunto de alterações, selecione o ícone Configurar Visualizaçõ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 a Branch Base para que ele forneça o relatório de comparação.

Na caixa de pesquisa na janela Resultados da Cobertura de Código, há várias maneiras de filtrar o relatório.

• Para Pesquisar por nome (Mostrar apenas aqueles que correspondem à cadeia de pesquisa na janela), digite a cadeia de pesquisa na caixa de pesquisa.
• Para Filtrar por tipo introduza o nome do tipo no campo de pesquisa.
• Para Mostrar tudo desmarque a caixa de pesquisa.
• Para Mostrar 100%totalmente coberto, digite "Coberto (%Lines)":"100" na caixa de pesquisa.
• Para Show (>0% && < 100%) parcialmente coberto, digite "Parcialmente coberto (%Lines)":"<##" substituindo o ## pela porcentagem coberta.
• Para Mostrar 0% coberto, digite "Não coberto (%Lines)":"0" na caixa de pesquisa.

Gerenciar resultados de 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 os dados do teste ou se executar apenas alguns dos testes de cada vez.

A janela Code Coverage Results também pode ser usada para visualizar resultados anteriores ou aqueles 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 visualizar um conjunto anterior de resultados, selecione-o no menu suspenso. O menu mostra uma lista temporária que é limpa quando você abre uma nova solução.

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

  A coloração da cobertura pode estar incorreta se o código-fonte tiver sido alterado desde que o arquivo de .coverage foi gerado.

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

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

Mesclar resultados de diferentes execuções

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

Por exemplo, suponha que, quando se executa um teste com a entrada "2", se verifica que 50% de uma determinada função está coberta. Quando você executa o teste uma segunda vez com a entrada "-2", você vê na visualização de coloração de cobertura que os outros 50% da função estão cobertos. Agora você mescla os resultados das duas execuções de teste, e a exibição de coloração de relatório e cobertura mostra que 100% da função foram cobertas.

Usar o ícone mesclar os resultados para fazer isso. Você pode escolher qualquer combinação de execuções recentes ou resultados importados. Se quiser combinar os resultados exportados, importe-os primeiro.

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

Limitações na fusão

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

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

• Se você mesclar resultados de testes de um projeto ASP.NET, os resultados para os testes separados serão exibidos, mas não combinados. Esse comportamento aplica-se apenas aos próprios componentes ASP.NET: os resultados de quaisquer outros assemblies serão combinados.

Excluir elementos dos resultados de 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 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

A exclusão de uma classe não exclui as 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

// 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>

• Coloque 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 compiladas como código não gerenciado (nativo), seja definindo a opção do compilador ou usando #pragma managed(off).

Observação

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 somente em assemblies que são carregados e para os quais um arquivo de .pdb está disponível no mesmo diretório que o arquivo .dll ou .exe. Portanto, em algumas circunstâncias, pode-se estender o conjunto de assemblies 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 de .runsettings. Por exemplo, você pode excluir assemblies de tipos específicos sem precisar adicionar atributos às suas classes. Para obter mais informações, consulte Personalizar análise de cobertura de código.

Analisar a cobertura de código no Azure Pipelines

Ao integrares o teu código, os testes correm no servidor de compilação juntamente com testes de outros membros da equipa. É útil analisar a cobertura de código no Azure Pipelines para obter a imagem mais up-toabrangente e atualizada da cobertura em todo o projeto. A cobertura de código no Azure Pipelines também inclui testes de sistema automatizados e outros testes codificados que normalmente não são executados nas máquinas de desenvolvimento.

Analise a cobertura de código a partir da linha de comando

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

1. Inicie o prompt de comando do desenvolvedor para Visual Studio:

   No menu Iniciar do Windows, pesquise Developer Command Prompt for VS e selecione o resultado da aplicação associado ao texto que pesquisou.

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

   vstest.console.exe MyTestAssembly.dll /EnableCodeCoverage
   

   Dica

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

Solução de problemas

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

Conteúdo relacionado

• Personalizar a análise de cobertura de código
• Solucionar problemas de cobertura de código
• Unidade testar seu código