Usare il code coverage per determinare la quantità di codice da testare

Per determinare la proporzione del codice del progetto testata da test codificati, ad esempio unit test, è possibile usare la funzionalità di code coverage di Visual Studio. Per proteggersi efficacemente dai bug, i test devono esercitare o "coprire" una gran parte del codice.

L'analisi del code coverage è possibile sia per il codice gestito (CLR) che per il codice non gestito (nativo). Sono supportati sia la strumentazione statica che quella dinamica. Per usare il code coverage negli scenari da riga di comando, usare vstest.console.exe o lo strumento Microsoft.CodeCoverage.Console, che è un'estensione per dotnet-coverage che supporta anche il codice nativo.

L'opzione Code coverage è disponibile nel menu Test quando si eseguono metodi di test usando Esplora test. La tabella dei risultati mostra la percentuale del codice eseguito in ogni assembly, classe e routine. L'editor di origine evidenzia il codice testato. È possibile esportare i risultati in formati comuni, ad esempio Cobertura.

Requisiti

La funzionalità di code coverage è disponibile solo in Visual Studio Enterprise Edition.

Annotazioni

Per la copertura del codice .NET, in alternativa è possibile usare lo strumento da riga di comando dotnet-coverage.

Analizzare la copertura del codice

1. Scegliere Analizza code coverage per tutti i test dal menu Test.

   

   Suggerimento

   È anche possibile eseguire la copertura del codice dalla finestra degli strumenti Test Explorer.

2. Dopo l'esecuzione dei test, per vedere quali righe sono state eseguite, scegliere Mostra evidenziazione della copertura del codice nella finestra Risultati della copertura del codice. Per impostazione predefinita, il codice coperto dai test è evidenziato in blu chiaro.

   

   Nell'elenco a discesa per l'opzione Mostra la colorazione della copertura del codice è possibile selezionare se la colorazione si applica alle linee di codice, ai glifi nel margine sinistro o a entrambi.

3. Per modificare i colori o usare il viso in grassetto, scegliere Strumenti>Opzioni>Ambiente>Tipi di carattere e colori>Mostra impostazioni per: Editor di testo. In Elementi di visualizzazione regolare le impostazioni per gli elementi "Copertura", ad esempio Copertura non toccata area.

   

4. Se i risultati mostrano una bassa copertura, esaminare le parti del codice che non vengono esercitate e scrivere altri test per coprirli. I team di sviluppo puntano in genere a circa 80% code coverage. In alcune situazioni, una copertura inferiore è accettabile. Ad esempio, una copertura inferiore è accettabile in cui viene generato codice da un modello standard.

Suggerimento

Per ottimizzare la copertura del codice:

• Disattivare l'ottimizzazione del compilatore.
• Se si usa codice non gestito (nativo), usare una compilazione di debug.
• Generare pdb file di simboli per ogni assembly.

Se non si ottengono i risultati previsti, vedere Risolvere i problemi di code coverage.

Non dimenticare di eseguire di nuovo il code coverage dopo l'aggiornamento del codice. I risultati della copertura e la colorazione del codice non vengono aggiornati automaticamente dopo la modifica del codice o quando si eseguono i test.

Suggerimento

A partire da Visual Studio 2022 versione 17.2, è possibile abilitare le funzionalità di code coverage più recenti selezionando Strumenti > Opzioni > funzionalità di anteprima dell'ambiente>, quindi selezionando Miglioramenti dell'esperienza di code coverage e quindi riavviando Visual Studio.

Rapporto in blocchi o righe

La copertura del codice viene conteggiata in blocchi. Block è una parte del codice con esattamente un punto di ingresso e di uscita. Se il flusso di controllo del programma passa attraverso un blocco durante un'esecuzione di test, tale blocco viene conteggiato come coperto. Il numero di volte in cui viene usato il blocco non influisce sul risultato.

È anche possibile visualizzare i risultati per le righe scegliendo Aggiungi/Rimuovi colonne nell'intestazione della tabella. Alcuni utenti preferiscono un conteggio delle righe perché le percentuali corrispondono più strettamente alle dimensioni dei frammenti visualizzati nel codice sorgente. Un blocco di calcolo lungo viene conteggiato come un singolo blocco anche se occupa molte righe.

Suggerimento

Una riga di codice può contenere più blocchi di codice. Se questo è il caso e l'esecuzione del test esegue tutti i blocchi di codice nella riga, viene conteggiata come una riga. Se sono stati eseguiti alcuni blocchi di codice ma non tutti i blocchi di codice nella riga, viene conteggiato come riga parziale.

Visualizzazioni dei risultati di code coverage

La finestra Risultati della copertura del codice struttura in genere il report nella gerarchia di progetto, classe e metodo. È possibile modificare questa opzione per visualizzare la copertura a livello di directory/file/metodo.

• Per visualizzare il report di origine, selezionare l'icona Configura visualizzazioni copertura del codice nella finestra Risultati copertura del codice. Selezionare quindi Visualizzazione di origine dall'elenco a discesa Stile report.

La finestra Risultati di Code Coverage mostra in genere il risultato per l'intera soluzione. I risultati possono essere filtrati per visualizzare i risultati solo per i file aggiornati nel ramo corrente.

• Per visualizzare il report del changeset, selezionare l'icona Configura visualizzazioni copertura del codice nella finestra Risultati copertura del codice. Quindi selezionare Report set di modifiche dal elenco a discesa Contenuto report. Aggiorna il repository attivo e il ramo di base per poter fornire il report di confronto.

Nella casella di ricerca della finestra Risultati Copertura del Codice è possibile filtrare il report in diversi modi.

• Per cercare per nome (mostra solo quelli che corrispondono alla stringa di ricerca nella finestra), immettere la stringa di ricerca nella casella di ricerca.
• Per Filtrare per tipo, inserire il nome del tipo nella casella di ricerca.
• Per Mostra tutto deselezionare la casella di ricerca.
• Per visualizzare 100% completamente coperto, immettere "Coperto (%Lines)":"100" nella casella di ricerca.
• Per visualizzare (>0% && < 100%) parzialmente coperto, immettere "Parzialmente coperto (%Lines)":"<##" sostituendo ## con la percentuale coperta.
• Per visualizzare 0% coperto, immettere "Non coperto (%Lines)":"0" nella casella di ricerca.

Gestire i risultati della copertura del codice

La finestra Risultati della copertura del codice mostra in genere il risultato dell'esecuzione più recente. I risultati variano se si modificano i dati di test o se si eseguono solo alcuni test ogni volta.

La finestra Risultati code coverage può essere usata anche per visualizzare i risultati precedenti o i risultati ottenuti su altri computer.

È possibile unire i risultati di diverse esecuzioni, ad esempio da esecuzioni che usano dati di test diversi.

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

• Per visualizzare i risultati di una sessione precedente, scegliere Importa risultati, passare alla cartella TestResults nella soluzione e importare un file con estensione coverage .

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

• Per rendere leggibili i risultati come testo, scegliere Esporta risultati, selezionare .xml come Salva come tipo. In questo modo viene generato un file .xml leggibile, che è possibile elaborare con altri strumenti o inviare facilmente in posta elettronica. È anche possibile selezionare i formati di esportazione, ad esempio Cobertura.

• Per inviare risultati a qualcun altro, inviare un file .coverage o un file esportato .xml. Possono quindi importare il file. Se hanno la stessa versione del codice sorgente, possono visualizzare la colorazione della copertura.

Unire i risultati da esecuzioni diverse

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

Si supponga, ad esempio, che quando si esegue un test con input "2", si scopre che 50% di una determinata funzione è coperta. Quando si esegue il test una seconda volta con l'input "-2", si noterà nella visualizzazione di colorazione della copertura che vengono coperti gli altri 50% della funzione. Ora si uniscono i risultati delle due esecuzioni di test e la visualizzazione di colorazione del report e della copertura mostra che 100% della funzione è stata coperta.

Usare Unire i risultati per eseguire questa operazione. È possibile scegliere qualsiasi combinazione di esecuzioni recenti o risultati importati. Se si desidera combinare i risultati esportati, è prima necessario importarli.

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

Limitazioni nell'unione

• Se si uniscono i dati di coverage da versioni diverse del codice, i risultati vengono visualizzati separatamente, ma non vengono combinati. Per ottenere risultati completamente combinati, usare la stessa compilazione del codice, modificando solo i dati di test.

• Se si unisce un file di risultati esportato e quindi importato, è possibile visualizzare solo i risultati in base alle righe, non ai blocchi. Usare il comando Aggiungi/Rimuovi colonne per visualizzare i dati della riga.

• Se si uniscono i risultati dei test di un progetto ASP.NET, i risultati per i test separati vengono visualizzati ma non combinati. Questo comportamento si applica solo agli elementi ASP.NET stessi: i risultati per qualsiasi altro assembly verranno combinati.

Escludere elementi dai risultati della copertura del codice

È possibile escludere elementi specifici nel codice dai punteggi di copertura, ad esempio se il codice viene generato da un modello di testo. Aggiungere l'attributo System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute a uno degli elementi di codice seguenti: classe, struct, metodo, proprietà, setter o getter di proprietà, evento.

Suggerimento

L'esclusione di una classe non esclude le classi derivate.

Per esempio:

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

C++

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

Escludere elementi nel codice C++ nativo

Per escludere 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 macro seguenti:

ExcludeFromCodeCoverage( ExclusionName, L"FunctionName");

ExcludeSourceFromCodeCoverage( ExclusionName, L"SourceFilePath");

• ExclusionName è qualsiasi nome univoco.

• FunctionName è un nome di funzione completo. 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 in una determinata directory: \\MyComputer\Source\UnitTests\*.cpp

• #include <CodeCoverage\CodeCoverage.h>

• Inserire chiamate alle macro di esclusione nello spazio dei nomi globale, non all'interno di alcuno spazio dei nomi o classe.

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

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

Annotazioni

Per escludere le funzioni nel codice C++/CLI, applicare l'attributo [System::Diagnostics::CodeAnalysis::ExcludeFromCodeCoverage] alla funzione. Questo è lo stesso di C#.

Includere o escludere elementi aggiuntivi

L'analisi della copertura del codice viene eseguita solo sugli assembly caricati e per i quali è disponibile un file con estensione .pdb nella stessa cartella del file .dll o .exe. Pertanto, in alcune circostanze, è possibile estendere il set di assembly inclusi recuperando copie dei file con estensione pdb appropriati.

È possibile esercitare un maggiore controllo sugli assembly e sugli elementi selezionati per l'analisi del code coverage scrivendo un file con estensione runsettings . Ad esempio, è possibile escludere assembly di determinati tipi senza dover aggiungere attributi alle relative classi. Per altre informazioni, vedere Personalizzare l'analisi code coverage.

Analizzare la copertura del codice in Azure Pipelines

Quando fai il check-in del tuo codice, i tuoi test vengono eseguiti sul server di build insieme ai test degli altri membri del team. È utile analizzare il code coverage in Azure Pipelines per ottenere il quadro più up-to-date e completo della copertura nell'intero progetto. Il code coverage in Azure Pipelines include anche test di sistema automatizzati e altri test codificati che in genere non vengono eseguiti nei computer di sviluppo.

Analizzare la copertura del codice dalla riga di comando

Per eseguire test dalla riga di comando, usare vstest.console.exe utilità. Code coverage è un'opzione dell'utilità vstest.console.exe richiamata dall'opzione /EnableCodeCoverage .

1. Avviare il prompt dei comandi per gli sviluppatori per Visual Studio:

   Nel menu Start di Windows cercare Developer Command Prompt for VS e selezionare il risultato dell'app associato al testo di ricerca.

2. Al prompt dei comandi eseguire il comando seguente:

   vstest.console.exe MyTestAssembly.dll /EnableCodeCoverage
   

   Suggerimento

   Per Developer PowerShell, la directory iniziale della shell è il percorso del progetto di Visual Studio. Sostituire MyTestAssembly.dll con il percorso e il nome del file di test. Per altre informazioni, vedere VSTest.Console.exe opzioni della riga di comando.

Risoluzione dei Problemi

Se non vengono visualizzati i risultati del code coverage, l'articolo Risolvere i problemi di code coverage può essere utile.

Contenuti correlati

• Personalizzare l'analisi della copertura del codice
• Risolvere i problemi di code coverage
• Testare il codice con unit test