Usando a cobertura de código para determinar como muito código está sendo testado

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

A análise de tinta de código pode ser aplicada ao código gerenciado (CLI) e não gerenciado (nativo).

A tinta de código é uma opção quando você executar métodos de teste usando o teste Explorer.A tabela de resultados mostra a porcentagem de código que foi executado em cada assembly, classe, e método.Além disso, o editor de código fonte mostra que foi testado.

Requisitos

• Visual Studio Ultimate, Visual Studio Premium

Para analisar a tinta de código em testes de unidade no teste Explorer

1. No menu de Testar , escolha Analisar Cobertura de Código.

2. Para ver que linhas foram executadas, escolha Mostrar Coloração de Cobertura de Código.

   Para alterar as cores, ou usar a cara em negrito, escolha Ferramentas, Opções, Ambiente, Fontes e Cores, Mostrar configurações de: Editor de Texto.Em Exibir Itens, ajuste os itens de tinta.

3. Se os resultados mostram pouca tinta, investigue que partes do código não estão sendo exercitadas, e grava mais testes para abranger-los.Equipes de desenvolvimento normalmente apontam para a tinta de código de aproximadamente 80%.Em algumas situações, uma inferior tinta é aceitável.Por exemplo, uma inferior tinta é aceitável onde qualquer código é gerado de um modelo padrão.

Dica
Para obter resultados precisos: Certifique-se de que a otimização do compilador é desativada. Se você estiver trabalhando com código não gerenciado (nativo), use uma construção de depuração. Certifique-se de que você está gerando arquivos de símbolo (.pdb) para cada assembly. Se você não receber os resultados que você espera, consulte Solução de problemas de cobertura de código.

Relatar nos blocos ou linhas

A tinta após é de código nos blocos.Um bloco é uma parte do código exatamente com um ponto de entrada e saída.Se o fluxo de controle do programa passa por um bloco durante um ensaio, o bloco é a contagem como tratado.O número de vezes que o bloco é usado não tem efeito no resultado.

Você pode também ter os resultados exibidos em termos de linhas escolhendo Adicionar/Remover Colunas no cabeçalho da tabela.Se o ensaio exercitou todos os blocos de código em qualquer linha de código, é contagem como uma linha.Onde uma linha contém alguns blocos de código que foram exercitados e algum que não era, esta é a contagem como uma linha parcial.

Alguns usuários preferem uma contagem de linhas porque os porcentagens correspondem mais apertadamente ao tamanho dos fragmentos que você vê no código-fonte.Um bloco o longo de cálculo contaria como um único bloco mesmo se ocupa várias linhas.

Gerenciando resultados de tinta de código

A janela de resultados de tinta de código mostra normalmente o resultado da execução mais recente.Os resultados irá variar se você altera seus dados de teste, ou se você executar somente alguns dos testes cada vez.

A janela de tinta de código também pode ser usada para exibir resultados anteriores, ou resultados obtidos em outros computadores.

Você pode mesclar os resultados das várias executa, por exemplo de executado usando dados de teste diferentes.

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

• Para exibir resultados de uma sessão anterior, escolha Resultados de tinta de código de importação, navega para a pasta de TestResults em sua solução, e importa um arquivo de .coverage.

  Coloração de tinta pode estar incorreta se o código-fonte foi alterado desde que o arquivo de .coverage foi gerado.

• Para fazer resultados legíveis como texto, escolha Resultados de tinta de código de exportação.Isso gera um arquivo legível de .coveragexml que você pode processar com as outras ferramentas ou facilmente enviar por email.

• Para enviar resultados a outra pessoa, envia um arquivo de .coverage ou um arquivo de .coveragexml exportado.Podem então importar o arquivo.Se têm a mesma versão de origem, podem ver coloração de tinta.

Mesclando resultados das sequências diferentes

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

Por exemplo, suponha que quando você executa um teste com a entrada “2 ", você localiza que 50% de uma função específica é abordado.Quando você executa o teste uma segunda vez com a entrada “- 2 " você vê no modo de coloração de tinta que a outro 50% de função é abordado.Agora você mescla os resultados dos dois ensaios, e a apresentação de relatório e de modo de exibição coloração de tinta que 100% da função foram abordados.

Use Resultados de tinta de código de mesclagem para fazer isso.Você pode escolher qualquer combinação de blocos recentes ou de resultados importados.Se você desejar combinar resultados exportados, você deve primeiro importá-los.

Use Resultados de tinta de código de exportação para salvar os resultados de uma operação de mesclagem.

Restrições em mesclar

• Se você mescla dados de tinta de versões diferentes do código, os resultados são mostrados separada, mas não são combinados.Para obter combinou totalmente resultados, usa a mesma compilação de código, modificando somente os dados de teste.

• Se você mescla os resultados arquivo que foi exportado e importado em seguida, você só podem exibir os resultados por linhas, não por blocos.Use o comando de Adicionar/Remover Colunas mostrar a linha dados.

• Se você mescla os resultados de teste do ASP.NET projeto, os resultados para os testes separados são exibidos, mas não combinados.Isso se aplica somente a artefatos próprios ASP.NET: os resultados para todos os outros conjuntos serão combinados.

Excluindo elementos de resultados de tinta de código

Convém excluir elementos específicos em seu código de resultados de tinta, por exemplo se o código é gerado de um modelo de texto.Adicione o atributo System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage a alguns dos seguintes elementos de código: classe, estrutura, método, propriedade, definidores de propriedade, evento ou getter.Observe que com exclusão de uma classe não exclui suas classes derivadas.

Por exemplo:

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 { ... }

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
{ ... }

Excluindo de elementos em código nativo de C++

Para excluir elementos (nativos) não gerenciado no código do 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 os seguintes macros:

-
ExcludeFromCodeCoverage(ExclusionName, L"Nomedafunção");

ExcludeSourceFromCodeCoverage(ExclusionName, L"SourceFilePath");

• ExclusionName é qualquer nome exclusivo.

• Nomedafunção é 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 caminho UNC de um arquivo de .cpp.Pode conter curingas.O seguinte exemplo deleta todos os arquivos em um diretório específico: \\MyComputer\Source\UnitTests\*.cpp

• #include <CodeCoverage\CodeCoverage.h>

• Chamadas de local para macros de exclusão no namespace global, não dentro de qualquer namespace ou classe.

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

• 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++/CLI código, aplique o atributo [System::Diagnostics::CodeAnalysis::ExcludeFromCodeCoverage] à função.Esse é o mesmo que para C#.

Incluindo ou excluir elementos adicionais

A análise de tinta de código é executada somente em assemblies que são carregados e para o qual um arquivo de .pdb está disponível no mesmo diretório que o arquivo .dll ou .exe.Portanto em algumas circunstâncias, você pode estender o conjunto de módulos (assemblies) que está incluído obter cópias dos arquivos apropriadas de .pdb.

Você pode exercitar mais controle sobre quais módulos e os elementos são selecionados para análise de tinta de código escrevendo um arquivo de .runsettings.Por exemplo, você pode excluir os assemblies de tipos específicos sem ter que adicionar atributos a sua classe.Para obter mais informações, consulte Personalizando análise de cobertura de código.

Para analisar a tinta de código no serviço de compilação

Quando você fizer o check-in de seu código, os testes serão executados no servidor de compilação, juntamente com todos os testes restantes de outros membros da equipe.(Se você ainda não tiver configurado isso, consulte Teste de execução em seu processo de compilação). É útil analisar a tinta de código no serviço de compilação, porque isso fornece a imagem a mais atualizado e mais abrangente de tinta no projeto inteiro.Também irá incluir os testes automatizados do sistema e outros teste codificados que você não geralmente executa em computadores de desenvolvimento.

1. No Team Explorer abra Construtores e então adicione ou edite uma definição de compilação.

2. Na página de Processo , expanda Testes automatizados, Fonte de teste, Configurações de Execução.Definir Tipo de configurações Arquivo de execuçãoTinta de código ativada.

   Se você tiver mais de uma definição de origem de teste, repita esta etapa para cada um.

   • Mas não há campo denominado Tipo de configurações Arquivo de execução.

     Em Testes automatizados, Assembly de teste e selecione escolher o botão de reticências [...] no final da linha.Na caixa de diálogo Adicionar/ensaio de edição , em Executor de Teste, escolha Executor de Teste do Visual Studio.

Depois de executar a compilação, os resultados da tinta de código são anexados ao ensaio e aparecem no resumo de compilação.

Para analisar a tinta de código na linha de comando

Para executar testes de linha de comando, use vstest.console.exe.A tinta de código é uma opção deste utilitário.Para obter mais informações, consulte Opções da linha de comando VSTest.Console.exe.

1. Iniciar o prompt de comando do desenvolvedor Visual Studio:

   No menu do Windows Iniciar , escolha Todos os Programas, Microsoft Visual Studio, Visual Studio Tools, Prompt de comando do desenvolvedor.

2. Execução:

   vstest.console.exe MyTestAssembly.dll /EnableCodeCoverage

Solução de problemas

Se você não vir resultados de tinta de código, consulte Solução de problemas de cobertura de código.

Recursos externos

Orientação

Teste para entrega contínuo com Visual Studio 2012 – capítulo 2: Testes de unidade: Testando o interior

Consulte também

Conceitos

Personalizando análise de cobertura de código

Solução de problemas de cobertura de código

Verificando o código usando testes de unidade