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 a ferramenta Microsoft.CodeCoverage.Console , que é uma extensão para dotnet-coverage , 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 a Cobertura de Código para 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 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 a Coloração da Cobertura de Código, pode selecionar se a coloração é aplicada a linhas de código, aos glifos na margem esquerda ou a 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 Mostrar itens, ajuste as configurações para os itens "Cobertura", por exemplo, Cobertura de Área 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 ficheiros .pdb (símbolo) para cada assemblagem.

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

Não se esqueça de executar novamente a cobertura de código depois de atualizar o 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, tu podes habilitar os recursos de cobertura de código mais recentes ao selecionar Ferramentas > Opções > Ambiente > Recursos de Pré-visualização, depois, selecionando Melhorias na experiência de cobertura de códigoe, em seguida, reiniciar o Visual Studio.

Relatório em blocos ou linhas

A cobertura do código é medida 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ê também pode ter os resultados exibidos por 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 na linha, é contada como uma única 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 de resultados de 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 visualizar o Relatório de fonte, selecione o ícone Configurar Vistas de Cobertura de Código na janela Resultados da Cobertura de Código. Em seguida, selecione Vista de Código-Fonte na lista suspensa Estilo de Relatório.

A janela Resultados da cobertura do 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 o Relatório de Changeset, selecione o ícone Configurar Visualizações de Cobertura de Código na janela Resultados de Cobertura de Código. Em seguida, selecione Relatório do Conjunto de Alterações na lista suspensa Conteúdo do Relatório. Atualizar o Repositório Ativo e a Ramificação Base para que se possa gerar 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 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 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 do TestResults na sua solução e importe um arquivo de .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 tiverem a mesma versão do código-fonte, podem ver a coloração da cobertura.

Fundir resultados de diferentes processos

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 você executa um teste com a entrada "2", você descobre que 50% de uma determinada função é coberta. Quando executa o teste uma segunda vez com a entrada "-2", vê na visualização de cobertura colorida 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.

Use para Mesclar resultados. 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 guardar os resultados de uma operação de fusão.

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. Este comportamento aplica-se apenas aos artefatos ASP.NET: os resultados de quaisquer 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 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)

Utilize 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 é realizada apenas em assemblies que são carregados e para os quais um ficheiro .pdb está disponível no mesmo diretório que o ficheiro .dll ou .exe. Portanto, em algumas circunstâncias, você pode estender o conjunto de assemblies incluído obtendo cópias dos arquivos de .pdb apropriados.

Você pode exercer mais controlo 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, consulte Personalizar análise de cobertura de código.

Analisar a cobertura de código no Azure Pipelines

Quando submete o seu código, os testes são executados no servidor de build junto 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 e selecione o resultado da aplicação relacionado com o texto da sua pesquisa.

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 de linha de comando.

Solução de problemas

Se não vir os resultados da cobertura de código, o artigo Resolver 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