Usare la funzionalità code coverage per determinare la quantità di codice testato

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.

Nota

Per il code coverage .NET, in alternativa è possibile usare lo strumento da riga di comando dotnet-coverage.

Analizzare il code coverage

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

   

   Suggerimento

   È anche possibile eseguire code coverage dalla finestra degli strumenti Esplora test .

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

   

   Nell'elenco a discesa per l'opzione Mostra colorazione code coverage è possibile selezionare se la colorazione si applica alle righe 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 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.

Suggerimento

Per ottimizzare il code coverage:

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

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

Ricordarsi di eseguire nuovamente il code coverage dopo aver aggiornato il 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 Update 2, è possibile abilitare risultati di test di code coverage più veloci selezionando Strumenti > Opzioni > funzionalità di anteprima dell'ambiente>, quindi selezionando Miglioramenti dell'esperienza di code coverage e quindi riavviando Visual Studio.

Report in blocchi o righe

Il code coverage viene conteggiato 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 l'esecuzione di un test, il blocco viene considerato analizzato. 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 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.

Suggerimento

Una riga di codice può contenere più di un blocco di codice. Se ciò si verifica e l'esecuzione del test analizza tutti i blocchi di codice nella riga, viene conteggiata una sola riga. Se vengono analizzati alcuni blocchi di codice, ma non tutti, la riga viene conteggiata come riga parziale.

Filtrare i risultati del code coverage

La finestra Risultati 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 set di modifiche, selezionare l'icona Configura visualizzazioni code coverage nella finestra Risultati code coverage. Selezionare quindi Report set di modifiche dall'elenco a discesa Contenuto report. Aggiornare il repository attivo e il ramo di base per confrontarlo per fornire il report di confronto.

Nella casella di ricerca nella finestra Risultati code coverage è 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 digitare immettere il nome del tipo nella casella di ricerca.
• Per Mostra tutto deselezionare la casella di ricerca.
• Per visualizzare il 100% completamente coperto, immettere "Coperto (%Lines)":"100" nella casella di ricerca.
• Per mostrare (>0% && < 100%) parzialmente coperto, immettere "Parzialmente coperto (%Lines)":"<##" sostituendo ## con la percentuale coperta.
• Per visualizzare il 0% coperto, immettere "Non coperto (%Righe)":"0" nella casella di ricerca.

Gestire i risultati di code coverage

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 Risultati code coverage può essere usata anche 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, sceglierlo 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 Import Code Coverage Results (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 Export Code Coverage Results (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. È anche possibile selezionare i formati di esportazione, ad esempio Cobertura.

• 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.

Unire i risultati di esecuzioni diverse

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. Ora si uniscono i risultati delle due esecuzioni di test e la visualizzazione di colorazione del report e della copertura mostra che il 100% della funzione è stato coperto.

Per eseguire questa operazione, usare merge dei risultati del code coverage. È possibile scegliere qualsiasi combinazione di esecuzioni recenti o risultati importati. Per combinare i risultati esportati, è necessario prima importarli.

Usare Export Code Coverage Results (Esporta risultati di code coverage) per salvare i risultati di un'operazione di merge.

Limitazioni del merge

• Se si uniscono i dati di coverage da versioni diverse del codice, i risultati vengono visualizzati separatamente, ma non vengono 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. Usare 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. Questo comportamento si applica solo agli elementi ASP.NET stessi: i risultati per qualsiasi altro assembly verranno combinati.

Escludere elementi dai risultati di code coverage

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.ExcludeFromCodeCoverageAttribute a uno dei seguenti elementi di codice: classe, struct, metodo, proprietà, metodo Set o Get di proprietà, evento.

Suggerimento

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

Ad 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 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(ExclusionName , L" FunctionName ");

ExcludeSourceFromCodeCoverage(ExclusionName , L" SourceFilePath ");

• NomeEsclusione è un 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::*

• SourceFilePath è il percorso LOCALE o UNC di un file .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).

Nota

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

Includere o escludere 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 Personalizzare l'analisi code coverage.

Analizzare code coverage in Azure Pipelines

Quando si controlla il codice, i test vengono eseguiti sul server di compilazione insieme ai test degli altri membri del team. È utile analizzare il code coverage in Azure Pipelines per ottenere un'immagine aggiornata e completa del code coverage dell'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 il code coverage 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 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 Opzioni della riga di comando di VSTest.Console.exe.

Risoluzione dei problemi

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

Contenuto correlato

• Personalizzare l'analisi code coverage
• Risolvere i problemi di code coverage
• Eseguire unit test del codice