Utilizzo di code coverage per determinare la quantità di codice testato

Per determinare quale percentuale del codice del progetto viene effettivamente testata dai test codificati come unit test, è possibile utilizzare la funzionalità code coverage di Visual Studio.Per una protezione efficace dai bug, i test devono esercitarsi una 'copertura' alla gran parte del codice.

L'analisi di code coverage può essere applicato sia a codice gestito (CLI) non gestito (nativo).

Il code coverage è un'opzione quando si eseguono i metodi di test utilizzando Esplora Risorse.La tabella dei risultati mostrano le percentuali di codice che sono state eseguite in ogni assembly, classe e metodo.Inoltre, l'editor standard mostra il codice che è stato testato.

Requisiti

• Visual Studio Ultimate, Visual Studio Premium

Per analizzare il code coverage sugli unit test di Esplora Risorse

1. Scegliere dal menu Test, scegliere Analizza code coverage.

2. Per vedere quali righe sono state eseguite, scegliere Mostra colorazione code coverage.

   Per modificare i colori o per utilizzare il grassetto, scegliere Strumenti, Opzioni, Ambiente, Tipi di carattere e colori, Visualizza impostazioni per: Editor di testo.In Elementi visualizzati, adeguare gli elementi di copertura.

3. Se i risultati mostrano una bassa copertura, esaminare quali parti del codice non vengono esercitate, e scrivere più test per riguardarli.I team di sviluppo in genere tendono a garantire l'80% di code coverage.In alcune situazioni, un basso code coverage è accettabile.Ad esempio, un basso code coverage è accettabile quando il codice viene generato da un modello standard.

Suggerimento
Per ottenere risultati accurati: Assicurarsi che l'ottimizzazione del compilatore sia disattivata. Se si utilizza codice non gestito (nativo), utilizzare una build di debug. Assicurarsi di generare file .pdb (simbolo) per ogni assembly. Se non si ottengono i risultati previsti, vedere Risoluzione dei problemi di code coverage.

Creazione rapporti in blocchi o linee.

Nel code coverage sono inclusi blocchi.Un blocco è un frammento di codice con esattamente un solo punto di ingresso e di uscita.Se il flusso di controllo del programma passa attraverso un blocco durante l'esecuzione di un test, il blocco viene conteggiato come analizzato.Il numero di volte che il blocco viene utilizzato, non ha effetto sul risultato.

È inoltre possibile che i risultati vengano visualizzati in termini di linee, scegliendo Aggiungi/Rimuovi colonne nell'intestazione della tabella.Se l'esecuzione del test verificasse tutti i blocchi di codice, in qualsiasi riga di codice, viene calcolata come una riga.Quando una riga contiene alcuni blocchi di codice verificati e altri che non lo sono, viene conteggiato come una riga parziale.

Alcuni utenti preferiscono un conteggio delle righe, in quanto le percentuali corrispondono maggiormente alla dimensione dei frammenti visualizzati nel codice sorgente.Un blocco lungo conterebbe come un singolo blocco anche se occupa più righe.

Gestione dei risultati di code coverage

Nella finestra risultati di code coverage, in genere viene visualizzato il risultato dell'esecuzione più recente.I risultati varieranno se cambiano i dati del test o se vengono eseguiti ogni volta alcuni test.

La finestra di code coverage, può inoltre essere utilizzata per visualizzare i risultati precedenti o risultati ottenuti in altri computer.

È possibile unire risultati di esecuzioni diverse, ad esempio le esecuzioni che utilizzano dati di test diversi.

• Per visualizzare un precedente insieme di risultati, selezionarlo dal menu a discesa.Il menu visualizza un elenco temporaneo che viene deselezionato quando si apre una nuova soluzione.

• Per visualizzare i risultati da una sessione precedente, scegliere Importa risultati di code coverage, passare alla cartella TestResults nella soluzione e includere un .coverage file.

  La colorazione di copertura potrebbe non essere corretta, se il codice sorgente è cambiato rispetto al file .coverage che è stato generato.

• Per rendere i risultati leggibili come testo, scegliere Esporta risultati di code coverage.Viene generato un file leggibile .coveragexml, che può essere elaborato con altri strumenti o facilmente inviato per posta elettronica.

• Per inviare i risultati a qualcun altro, invia un file .coverage o un file esportato .coveragexml.Essi possono quindi importare il file.Se hanno la stessa versione del codice sorgente, possono visualizzare la colorazione di code coverage.

Unione dei risultati di esecuzioni diversi

In alcune situazioni, blocchi diversi nel codice verranno utilizzati a seconda dei dati di test.Pertanto, è necessario combinare i risultati esecuzioni di test diversi.

Ad esempio, si supponga che quando si esegue un test con input "2 ", si scopre che il 50% di una particolare funzione è analizzata.Quando si esegue il test una seconda volta con l'input "- 2 ", si vede che nella visualizzazione di colorazione l'altro 50% della funzione viene analizzata.Ora si uniscono i risultati delle due esecuzioni dei test, la relazione e la vista di copertura e colorazione mostrano che il 100% della funzione era coperto.

Utilizzare Merge Code Coverage Results per questo scopo.È possibile scegliere qualsiasi combinazione di esecuzioni recenti o di risultati importati.Se si desidera combinare i risultati esportati, è necessario includerli prima.

Utilizzare Esporta risultati di code coverage per salvare i risultati di un'operazione di unione.

Limitazioni di unione

• Se si uniscono i dati di copertura di versioni differenti del codice, i risultati vengono visualizzati separatamente, ma non vengono combinati.Per ottenere risultati completamente combinati, utilizzare lo stesso formato di compilazione del codice, cambiando solamente i dati di test.

• Se si uniscono un file di risultati che è stato esportato quindi è stato importato, è possibile visualizzare solo i risultati delle righe, non dei blocchi.Utilizzare il comando Aggiungi/Rimuovi colonne per visualizzare i dati della riga.

• Se si unisce i risultati dei test di un progetto ASP.NET, i risultati di test separati vengono visualizzati, ma non vengono combinati.Si applica solo agli elementi stessi ASP.NET: i risultati per tutti gli altri assembly saranno combinati.

Esclusione di elementi dai risultati di code coverage

Può essere necessario escludere elementi specifici nel codice dai punteggi di code coverage, ad esempio se il codice viene generato da un modello di testo.Aggiungere l'attributo System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage a uno dei seguenti elementi di codice: classe, struct, metodo, proprietà, proprietà di setter o getter, evento.Si noti che l'esclusione di una classe non esclude le relative classi derivate.

Ad esempio:

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

Esclusione di elementi nel codice C++ nativo

Per escludere gli elementi (nativi) non gestiti nel codice 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)

Utilizzare le seguenti macro:

-
ExcludeFromCodeCoverage(ExclusionName, L"FunctionName");

ExcludeSourceFromCodeCoverage(ExclusionName, L"SourceFilePath");

• ExclusionName è qualsiasi nome univoco.

• FunctionName è un nome completo di una funzione.Può contenere caratteri jolly.Ad esempio, per escludere tutte le funzioni di una classe, scrivere MyNamespace::MyClass::*

• SourceFilePath è il percorso locale o UNC di un file .cpp.Può contenere caratteri jolly.Nell'esempio seguente vengono esclusi tutti i file di una precisa directory: \\MyComputer\Source\UnitTests\*.cpp

• #include <CodeCoverage\CodeCoverage.h>

• Effettuare le chiamate alle macro di esclusione nello spazio dei nomi globale, non in qualsiasi spazio dei nomi o classe.

• È possibile inserire esclusioni sia nel file di codice dello unit test, oppure nel file di codice dell'applicazione.

• Il devono essere compilate come codice non gestito (nativo), impostare l'opzione del compilatore o utilizzando #pragma managed(off).

[!NOTA]

Per escludere funzioni in C++/CLI codice, applicare l'attributo [System::Diagnostics::CodeAnalysis::ExcludeFromCodeCoverage] alla funzione.Questa è la stessa per C#.

Includendo o escludendo gli elementi aggiuntivi

L'analisi di code coverage viene eseguita solo su assembly caricati, per i quali è disponibile un file .pdb nella stessa directory del file .dll oppure del file .exe.Pertanto in alcune circostanze, è possibile estendere il set di assembly che viene incluso per ottenere copie appropriate dei file .pdb.

Per l'analisi di code coverage è possibile esercitare un maggiore controllo sugli assembly e sugli elementi che sono selezionati scrivendo un file .runsettings.Ad esempio, è possibile escludere particolari tipi di assembly senza dover aggiungere attributi alle classi.Per ulteriori informazioni, vedere Personalizzazione dell'analisi code coverage.

L'Analisi di code coverage nel servizio di compilazione

Quando si controlla il codice, i test verranno eseguiti sul server di compilazione, con tutti gli altri test di altri membri del team.(Se questo non è stato già impostato, vedere Eseguire test nel processo di compilazione). Nel servizio di compilazione è utile analizzare il code coverage, perché fornisce un'immagine aggiornata e completa della copertura dell'intero progetto.Esso includerà i test di sistema automatizzati e altri test codificati che normalmente non vengono eseguiti sui computer di sviluppo.

1. In Team Explorer, aprire Compilazioni, e aggiungere o modificare una definizione di compilazione.

2. Nella pagina Processo, espandere Test automatizzati, Origine test, Impostazioni di esecuzione test.Impostare Tipo del file dell'esecuzione dei test a Code coverage abilitato.

   Se si dispone di più di una definizione di origine del test, ripetere questo passaggio per ciascuna di esse.

   • Ma non vi è nessun campo denominato Tipo del file dell'esecuzione dei test.

     In Test automatizzati, selezionare Assembly di test e premere il pulsante con i puntini di sospensione [...] alla fine della riga.Nella finestra di dialogo Aggiungi/Modifica esecuzione dei test, in Test Runner, scegliere Visual Studio Test Runner.

Dopo la compilazione, i risultati di code coverage sono associati all'esecuzione dei test e vengo visualizzati nel riepilogo compilazione.

L'Analisi del code coverage in una riga di comando

Per eseguire un test dalla riga di comando, utilizzare vstest.console.exe.Il code coverage è un'opzione di questa utilità.Per ulteriori informazioni, vedere Opzioni della riga di comando di VSTest.Console.exe.

1. Avviare il prompt dei comandi di Visual Studio Developer:

   Nella menu della finestra Avvia, scegliere Tutti i programmi, Microsoft Visual Studio, Strumenti Visual Studio, Prompt dei comandi sviluppatore.

2. Esegui:

   vstest.console.exe MyTestAssembly.dll /EnableCodeCoverage

Risoluzione dei problemi

Se non è possibile visualizzare i risultati di code coverage, vedere Risoluzione dei problemi di code coverage.

Risorse esterne

Linee guida

Verifica della Continuous Delivery con Visual Studio 2012 – Capitolo 2: Test delle Unità: Test dell'interno

Vedere anche

Concetti

Personalizzazione dell'analisi code coverage

Risoluzione dei problemi di code coverage

Verifica del codice tramite unit test