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

 

Data di pubblicazione: aprile 2016

Per la documentazione più recente di Visual Studio 2017 RC, vedere Documentazione di Visual Studio 2017 RC.

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 analizzare o "coprire" gran parte del codice.

L'analisi di code coverage può essere applicata sia al codice gestito (CLI) che a quello non gestito (nativo).

Il code coverage è un'opzione per l'esecuzione dei metodi di test utilizzando Esplora test. Nella tabella dei risultati viene illustrata la percentuale di codice che è stata eseguita per ogni assembly, classe e metodo. Inoltre, nell'editor standard viene visualizzato il codice testato.

Risultati del code coverage con colorazione

Requisiti

  • Visual Studio Enterprise

Per analizzare il code coverage su unit test in Esplora test

  1. Scegliere Analizza code coverage dal menu Test.

  2. Per vedere quali righe sono state eseguite, scegliere Icona Mostra colorazione code coverageMostra 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 regolare gli elementi di code coverage.

  3. Se i risultati mostrano un code coverage basso, esaminare quali parti del codice non vengono analizzate e scrivere altri test per includerle nel code coverage. I team di sviluppo in genere mirano a coprire l'80% del code coverage. In alcune situazioni, un code coverage basso è accettabile. Ad esempio, un code coverage basso è accettabile quando il codice viene generato da un modello standard.

System_CAPS_ICON_tip.jpg Suggerimento

Per ottenere risultati accurati:

  • Assicurarsi che l'ottimizzazione del compilatore sia disattivata.

    Se si utilizza codice non gestito (nativo), utilizzare una compilazione di debug.

  • Assicurarsi che vengano generati i file con estensione pdb (simbolo) per ogni assembly.

Se non si ottengono i risultati previsti, vedere Risoluzione dei problemi di code coverage. . Non dimenticare di eseguire nuovamente il code coverage dopo aver aggiornato il codice. I risultati di code coverage e la colorazione del codice non vengono aggiornati automaticamente dopo aver modificato il codice o quando si eseguono i test.

Il code coverage è conteggiato in 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 influisce sul risultato.

È inoltre possibile che i risultati vengano visualizzati in termini di righe, scegliendo Aggiungi/Rimuovi colonne nell'intestazione della tabella. Se l'esecuzione del test analizza tutti i blocchi di codice in una riga di codice, viene conteggiata una sola riga. Quando una riga contiene blocchi di codice analizzati e non analizzati, viene conteggiata una riga parziale.

Alcuni utenti preferiscono il conteggio delle righe in quanto le percentuali più corrispondono alla dimensione dei frammenti presenti nel codice sorgente. Un lungo blocco di calcolo verrebbe conteggiato come un singolo blocco anche se occupa più righe.

Nella finestra Risultati code coverage in genere viene visualizzato il risultato dell'esecuzione più recente. I risultati variano se si modificano i dati di test o se ogni volta vengono eseguiti solo alcuni testi.

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

È possibile eseguire il merge dei risultati di esecuzioni diverse, ad esempio le esecuzioni che utilizzano dati di test diversi.

  • Per visualizzare un precedente set di risultati, selezionarlo dal menu a discesa. Nel menu viene visualizzato un elenco temporaneo che viene cancellato 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 importare un file con estensione coverage.

    La colorazione del code coverage potrebbe non essere corretta se il codice sorgente è stato modificato dopo la generazione del file con estensione coverage.

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

  • Per inviare i risultati a un altro utente, inviare un file con estensione coverage o un file esportato con estensione coveragexml. L'utente potrà quindi importare il file. Se l'utente dispone della stessa versione del codice sorgente, potrà vedere la colorazione del code coverage.

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

Ad esempio, si supponga che quando si esegue un test con input "2 ", si rileva che viene analizzato il 50% di una particolare funzione e quando si esegue il test una seconda volta con l'input "- 2 ", si rileva nella visualizzazione della colorazione di code coverage che viene analizzato l'altro 50% della funzione. A questo punto viene eseguito il merge dei risultati delle due esecuzioni dei test e nel report e nella visualizzazione della colorazione di code coverage viene indicato che il 100% della funzione è stato analizzato.

A tale scopo, usare il Icona per il pulsante di esecuzione del merge nella finestra Code coveragemerge dei risultati di code coverage. È possibile scegliere qualsiasi combinazione di esecuzioni recenti o risultati importati. Per combinare i risultati esportati, è necessario prima importarli.

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

Limitazioni del merge

  • Se si esegue il merge dei dati di code coverage di versioni differenti del codice, vengono visualizzati i risultati separati ma non combinati. Per ottenere risultati combinati, utilizzare la stessa compilazione del codice, cambiando solo i dati di test.

  • Se si esegue il merge di un file di risultati che è stato esportato e poi importato, è possibile visualizzare solo i risultati per riga e non per blocco. Utilizzare il comando Aggiungi/Rimuovi colonne per visualizzare i dati della riga.

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

Potrebbe essere necessario escludere specifici elementi nel codice dai risultati 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à, metodo Set o Get di proprietà, 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 { ... }  
  

Esclusione di elementi nel codice C++ nativo

Per escludere gli elementi non gestiti (nativi) 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( NomeEsclusione , L" NomeFunzione ");

ExcludeSourceFromCodeCoverage( NomeEsclusione , L" PercorsoFileOrigine ");

  • NomeEsclusione è qualsiasi nome univoco.

  • NomeFunzione è un nome completo di funzione. Si possono utilizzare i caratteri jolly. Ad esempio, per escludere tutte le funzioni di una classe, scrivere MyNamespace::MyClass::*

  • PercorsoFileOrigine è il percorso locale o UNC di un file con estensione cpp. Si possono utilizzare i caratteri jolly. L'esempio seguente esclude tutti i file in una directory specifica: \\MyComputer\Source\UnitTests\*.cpp

  • #include <CodeCoverage\CodeCoverage.h>

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

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

  • Le esclusione devono essere compilate come codice non gestito (nativo), impostando l'opzione del compilatore oppure utilizzando #pragma managed(off).

System_CAPS_ICON_note.jpg Nota

Per escludere funzioni nel codice gestito C++/CLI applicare l'attributo [System::Diagnostics::CodeAnalysis::ExcludeFromCodeCoverage] alla funzione. L'operazione è uguale in C#.

Inclusione o esclusione di elementi aggiuntivi

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

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

Quando si controlla il codice, i test vengono eseguiti sul server di compilazione insieme a tutti gli altri test degli altri membri del team. Se questo aspetto non è già stato configurato, vedere Eseguire test nel processo di compilazione. È utile analizzare il code coverage nel servizio di compilazione perché viene fornita un'immagine aggiornata e completa del code coverage dell'intero progetto. Vengono inclusi i test di sistema automatizzati e altri test codificati che normalmente non vengono eseguiti nei 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 esecuzione test. Impostare Tipo di file di impostazioni esecuzione test su Code coverage abilitato.

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

    • Non è presente alcun campo denominato Tipo di file di impostazioni esecuzione 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.

Impostazione della definizione di compilazione per il code coverage

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

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

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

    Nel menu Start di Windows scegliere Tutti i programmi, Microsoft Visual Studio, Strumenti di Visual Studio, Prompt dei comandi per gli sviluppatori.

  2. Eseguire:

    vstest.console.exe MyTestAssembly.dll /EnableCodeCoverage

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

Linee guida

Test per la distribuzione continua con Visual Studio 2012 – Capitolo 2: Unit Testing: Test interni

Personalizzazione dell'analisi code coverage
Risoluzione dei problemi di code coverage
Eseguire unit test del codice

Mostra: