Condividi tramite

Personalizzazione dell'analisi code coverage

  • Articolo

Per impostazione predefinita, lo strumento Code Coverage di Visual Studio 2012 analizza tutti gli assembly della soluzione (.exe/.dll) caricati durante gli unit test.È consigliabile mantenere questa impostazione predefinita, in quanto funziona bene per la maggior parte dei casi.Per ulteriori informazioni, vedere Utilizzo di code coverage per determinare la quantità di codice testato.

Prima di personalizzare il comportamento di code coverage, considerare alcune alternative:

  • Si desidera escludere il codice di test dai risultati di code coverage e includere solo il codice dell'applicazione.

    Aggiungere ExcludeFromCodeCoverage Attribute alla propria classe di test.

  • Si desidera includere assembly che non fanno parte della soluzione.

    Leggere i file pdb per questi assembly e copiarli nella stessa cartella dei file DLL di assembly.

Per personalizzare il comportamento di code coverage, copiare esempio alla fine di questo argomento e aggiungerlo alla soluzione mediante l'estensione di file .runsettings.Modificarlo alle proprie esigenze quindi scegliere dal menu Test, scegliere Impostazioni test, file Seleziona impostazioni test.Il resto di questo argomento descrive più dettagliatamente questa procedura.

Il file .runsettings

Le impostazioni avanzate di code coverage vengono specificate in un file .runsettings.Si tratta del file di configurazione utilizzato dagli strumenti di unit test.Si consiglia di copiare copia esempio alla fine di questo argomento e di modificarlo per soddisfare le proprie esigenze.

  • Cosa che si è verificato al file con estensione .testsettings utilizzato in Visual Studio 2010?

    In Visual Studio 2010, il file .testsettings si applica solo agli unit test basati sul framework MSTest.In Visual Studio 2012, gli strumenti di test sono validi non solo per MSTest, ma anche altri framework come NUnit e a xunit.net.Il file .testsettings non funzionerà con essi.Il file .runsettings è progettato per personalizzare gli strumenti di test in modo da funzionare con tutti i framework di test.

Per personalizzare code coverage, sarà necessario aggiungere un file .runsettings alla propria soluzione:

  1. Aggiungere un file XML come elemento di soluzione con estensione .runsettings:

    In Esplora soluzioni, dal menu di scelta rapida della propria soluzione, scegliere Aggiungi, Nuovo elementoe selezionare File XML.Salvare il file con una fine del nome come CodeCoverage.runsettings

  2. Aggiungere il contenuto fornito nell'esempio alla fine di questo argomento quindi personalizzarlo secondo le proprie esigenze come descritto nelle sezioni seguenti.

  3. Scegliere dal menu Test, scegliere Impostazioni test, Seleziona file di impostazioni test e selezionare il file.

  4. Quando si esegue Test, Analizza code coverage, questo file .runsettings controllerà il suo comportamento.

  5. Per attivare e disattivare le impostazioni personalizzate, deselezionare o selezionare il file in Test, menu Impostazioni test.

Menu Impostazioni test con file di impostazioni personalizzato

Altri aspetti degli unit test possono essere configurati nello stesso file di .runsettings.Per ulteriori informazioni, vedere Verifica del codice tramite unit test.

JJ159530.collapse_all(it-it,VS.110).gifSpecificare i percorsi di ricerca dei simboli

Code coverage richiede che i simboli (file con estensione pdb) per gli assembly siano presenti.Per gli assembly compilati dalla propria soluzione, i file di simboli sono solitamente presenti accanto ai file binari e code coverage eseguiti automaticamente.Ma in alcuni casi, è consigliabile includere assembly a cui si fa riferimento nella propria analisi code coverage.In alcuni casi, i file PDB non possono essere adiacenti ai binari, ma è possibile specificare il percorso di ricerca dei simboli nel file .runsettings.

         <SymbolSearchPaths>              
               <Path>\\mybuildshare\builds\ProjectX</Path>
               <!--More paths if required-->
         </SymbolSearchPaths>
Nota di avvisoAttenzione

La risoluzione dei simboli può richiedere tempo, in particolare quando si utilizza un percorso di un file remoto con molti assembly.Di conseguenza, si consiglia di copiare i file remoto con estensione pdb nello stesso percorso locale (.dll ed .exe) dei file binari.

JJ159530.collapse_all(it-it,VS.110).gifEsclusione ed inclusione

È possibile escludere gli assembly specificati dall'analisi code coverage.Ad esempio:

<ModulePaths>
  <Exclude>
   <ModulePath>Fabrikam.Math.UnitTest.dll</ModulePath>
   <!-- Add more ModulePath nodes here. -->
  </Exclude>
</ModulePaths>

In alternativa, è possibile specificare gli assembly che devono essere inclusi.Questo approccio presenta lo svantaggio che quando si aggiungono più assembly alla soluzione, è necessario ricordare di aggiungerli all'elenco:

<ModulePaths>
  <Include>
   <ModulePath>Fabrikam.Math.dll</ModulePath>
   <!-- Add more ModulePath nodes here. -->
  </Include>
</ModulePaths>

Se <Include> è vuoto, quindi l'elaborazione di code coverage include tutti gli assembly (file .dll and .exe) caricati e per i quali i file .pdb possono essere trovati, ad eccezione degli elementi che soddisfano una clausola in un elenco <Exclude>.

Include viene elaborato prima Exclude.

JJ159530.collapse_all(it-it,VS.110).gifEspressioni regolari

Includere ed escludere nodi che utilizzano le espressioni regolari.Per ulteriori informazioni, vedere Utilizzo delle espressioni regolari in Visual Studio.Le espressioni regolari non sono la stessa cosa dei caratteri jolly.In particolare:

  1. . * corrisponde ad una stringa di alcuni caratteri

  2. \. corrisponde ad un punto ".")

  3. \( \) corrisponde alle parentesi "( )"

  4. \\ corrisponde al del delimitatore del percorso del file "\"

  5. ^ corrisponde all'inizio della stringa

  6. $ corrisponde alla fine della stringa

Tutte le corrispondenze fanno distinzione tra maiuscole e minuscole.

Ad esempio:

<ModulePaths>
  <Include>
    <!-- Include all loaded .dll assemblies (but not .exe assemblies): -->
    <ModulePath>.*\.dll$</ModulePath>
  </Include>
  <Exclude>
    <!-- But exclude some assemblies: -->
    <ModulePath>.*\\Fabrikam\.MyTests1\.dll$</ModulePath>
    <!-- Exclude all file paths that contain "Temp": -->
    <ModulePath>.*Temp.*</ModulePath> 
  </Exclude>
</ModulePaths>
Nota di avvisoAttenzione

Se è presente un errore in un'espressione regolare, come un carattere senza codice di escape e parentesi non corrispondenti, l'analisi di code coverage non funzionerà.

JJ159530.collapse_all(it-it,VS.110).gifAltri modi per includere o escludere elementi

Vedere l'esempio alla fine di questo argomento per gli esempi.

  • ModulePath – Assembly specificato dal percorso del file assembly.

  • CompanyName – assembly corrispondenti per l'attributo della società.

  • PublicKeyToken – assembly firmati corrispondenti per il token di chiave pubblica.Ad esempio per soddisfare tutti i componenti ed estensioni di Visual Studio, utilizzare <PublicKeyToken>^B03F5F7F11D50A3A$</PublicKeyToken>.

  • Source – elementi corrispondenti per il nome del percorso del file di origine in cui sono definiti.

  • Attribute – elementi corrispondenti ai quali sia connesso un particolare attributo.Specificare il nome completo dell'attributo, includendo "Attributo" alla fine del nome.

  • Function – procedure, funzioni, o metodi corrispondenti per il nome completo.

Corrispondere ad un nome di funzione

L'espressione regolare deve corrispondere al nome completo della funzione, incluso lo spazio dei nomi, il nome della classe, il nome del metodo e l'elenco di parametri.Di seguito è riportato un esempio:

  • C# o Visual Basic: Fabrikam.Math.LocalMath.SquareRoot(double)

  • C++: Fabrikam::Math::LocalMath::SquareRoot(double)

<Functions>
  <Include>
    <!-- Include methods in the Fabrikam namespace: -->
    <Function>^Fabrikam\..*</Function>
    <!-- Include all methods named EqualTo: -->
    <Function>.*.\EqualTo\(.*</Function>
  </Include>
  <Exclude>
    <!-- Exclude methods in a class or namespace named UnitTest: -->
    <Function>.*\.UnitTest\..*</Function>
  </Exclude>
</Functions>

Come specificare file .runsettings durante l'esecuzione dei test

JJ159530.collapse_all(it-it,VS.110).gifPer personalizzare i runsettings nei test di Visual Studio

Scegliere Test, Impostazioni test, Seleziona file di impostazioni test e selezionare il file .runsettings.Il file viene visualizzato nel menu di impostazioni di test ed è possibile selezionarli o annullare l'operazione.Mentre selezionato, il file .runsettings viene applicato ogni volta che si utilizza Analizza code coverage.

JJ159530.collapse_all(it-it,VS.110).gifPer personalizzare le impostazioni esecuzione test in un test della riga di comando

Per eseguire un test dalla riga di comando, utilizzare vstest.console.exe.Il file di impostazioni è un parametro di questa utilità.Per ulteriori informazioni, vedere Utilizzo di VSTest.Console dalla riga di comando.

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

    In Windows Avvia, scegliere Tutti i programmi, Microsoft Visual Studio, Strumenti Visual Studio, Prompt dei comandi sviluppatore.

  2. Esegui:

    vstest.console.exe MyTestAssembly.dll /EnableCodeCoverage /Settings:CodeCoverage.runsettings

JJ159530.collapse_all(it-it,VS.110).gifPer personalizzare le impostazioni esecuzione test in una definizione di compilazione

È possibile ottenere dati di code coverage da Team Build.

Specifica delle impostazioni di esecuzione in una definizione di compilazione

  1. Assicurarsi che il file .runsettings sia selezionato.

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

  3. Nella pagina Processo, espandere Test automatizzati, Origine test, Impostazioni di esecuzione test.Selezionare il file .runsettings.

    • Ma Assembly di test appare anziché Origine test.Quando si prova ad impostare il campo Impostazioni di esecuzione test, è possibile selezionare solo i file .testsettings.

      In Test automatizzati, Assembly di testselezionare e scegliere [...] alla fine della riga.Nella finestra di dialogo Aggiungi/Modifica esecuzione dei test, impostare Test Runner a Visual Studio Test Runner.

I risultati vengono visualizzati nella sezione relativa al rapporto di compilazione.

File .runsettings di esempio

Copiare questo codice e modificarlo secondo le proprie esigenze.Questa è l'impostazione predefinita del file .runsettings.

<?xml version="1.0" encoding="utf-8"?>
<!-- File name extension must be .runsettings -->
<RunSettings>
  <DataCollectionRunSettings>
    <DataCollectors>
      <DataCollector friendlyName="Code Coverage" uri="datacollector://Microsoft/CodeCoverage/2.0" assemblyQualifiedName="Microsoft.VisualStudio.Coverage.DynamicCoverageDataCollector, Microsoft.VisualStudio.TraceCollector, Version=11.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
        <Configuration>
          <CodeCoverage>
<!--
Additional paths to search for .pdb (symbol) files. Symbols must be found for modules to be instrumented.
If .pdb files are in the same folder as the .dll or .exe files, they are automatically found. Otherwise, specify them here.
Note that searching for symbols increases code coverage runtime. So keep this small and local.
--> 
<!--           
            <SymbolSearchPaths>              
                   <Path>C:\Users\User\Documents\Visual Studio 2012\Projects\ProjectX\bin\Debug</Path>
                   <Path>\\mybuildshare\builds\ProjectX</Path>
            </SymbolSearchPaths>
-->

<!--
About include/exclude lists:
Empty "Include" clauses imply all; empty "Exclude" clauses imply none.
Each element in the list is a regular expression (ECMAScript syntax). See https://msdn.microsoft.com/library/2k3te2cs.aspx.
An item must first match at least one entry in the include list to be included.
Included items must then not match any entries in the exclude list to remain included.
-->

            <!-- Match assembly file paths: -->
            <ModulePaths>
              <Include>
                <ModulePath>.*\.dll$</ModulePath>
                <ModulePath>.*\.exe$</ModulePath>
              </Include>
              <Exclude>
                <ModulePath>.*CPPUnitTestFramework.*</ModulePath>
              </Exclude>
            </ModulePaths>

            <!-- Match fully qualified names of functions: -->
            <!-- (Use "\." to delimit namespaces in C# or Visual Basic, "::" in C++.)  -->
            <Functions>
              <Exclude>
                <Function>^Fabrikam\.UnitTest\..*</Function>         
                <Function>^std::.*</Function>
                <Function>^ATL::.*</Function>
                <Function>.*::__GetTestMethodInfo.*</Function>
                <Function>^Microsoft::VisualStudio::CppCodeCoverageFramework::.*</Function>
                <Function>^Microsoft::VisualStudio::CppUnitTestFramework::.*</Function>
              </Exclude>
            </Functions>

            <!-- Match attributes on any code element: -->
            <Attributes>
              <Exclude>
                <!-- Don’t forget "Attribute" at the end of the name -->
                <Attribute>^System.Diagnostics.DebuggerHiddenAttribute$</Attribute>
                <Attribute>^System.Diagnostics.DebuggerNonUserCodeAttribute$</Attribute>
                <Attribute>^System.Runtime.CompilerServices.CompilerGeneratedAttribute$</Attribute>
                <Attribute>^System.CodeDom.Compiler.GeneratedCodeAttribute$</Attribute>
                <Attribute>^System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute$</Attribute>
              </Exclude>
            </Attributes>

            <!-- Match the path of the source files in which each method is defined: -->
            <Sources>
              <Exclude>
                <Source>.*\\atlmfc\\.*</Source>
                <Source>.*\\vctools\\.*</Source>
                <Source>.*\\public\\sdk\\.*</Source>
                <Source>.*\\microsoft sdks\\.*</Source>
                <Source>.*\\vc\\include\\.*</Source>
              </Exclude>
            </Sources>

            <!-- Match the company name property in the assembly: -->
            <CompanyNames>
              <Exclude>
                <CompanyName>.*microsoft.*</CompanyName>
              </Exclude>
            </CompanyNames>

            <!-- Match the public key token of a signed assembly: -->
            <PublicKeyTokens>
              <!-- Exclude Visual Studio extensions: -->
              <Exclude>
                <PublicKeyToken>^B77A5C561934E089$</PublicKeyToken>
                <PublicKeyToken>^B03F5F7F11D50A3A$</PublicKeyToken>
                <PublicKeyToken>^31BF3856AD364E35$</PublicKeyToken>
                <PublicKeyToken>^89845DCD8080CC91$</PublicKeyToken>
                <PublicKeyToken>^71E9BCE111E9429C$</PublicKeyToken>
                <PublicKeyToken>^8F50407C4E9E73B6$</PublicKeyToken>
                <PublicKeyToken>^E361AF139669C375$</PublicKeyToken>
              </Exclude>
            </PublicKeyTokens>


            <!-- We recommend you do not change the following values: -->
            <UseVerifiableInstrumentation>True</UseVerifiableInstrumentation>
            <AllowLowIntegrityProcesses>True</AllowLowIntegrityProcesses>
            <CollectFromChildProcesses>True</CollectFromChildProcesses>
            <CollectAspDotNet>False</CollectAspDotNet>

          </CodeCoverage>
        </Configuration>
      </DataCollector>
    </DataCollectors>
  </DataCollectionRunSettings>
</RunSettings>

Vedere anche

Concetti

Verifica del codice tramite unit test

Altre risorse

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