Codedekking gebruiken om te bepalen hoeveel code wordt getest

Als u wilt bepalen welk deel van de code van uw project wordt getest door gecodeerde tests zoals eenheidstests, kunt u de functie voor codedekking van Visual Studio gebruiken. Om effectief te beschermen tegen bugs, moeten uw tests een groot deel van uw code uittesten of dekken.

Analyse van codedekking is mogelijk voor zowel beheerde (CLR) als niet-beheerde (systeemeigen) code. Zowel statische als dynamische instrumentatie worden ondersteund. Als u codedekking wilt gebruiken in opdrachtregelscenario's, gebruikt u vstest.console.exe of hulpprogramma Microsoft.CodeCoverage.Console. Dit is een extensie voor dotnet-dekking die ook systeemeigen code ondersteunt.

De optie code coverage is beschikbaar in het menu Testen wanneer u testmethoden uitvoert met behulp van Test Explorer. In de resultatentabel ziet u het percentage van de code die in elke assembly, klasse en procedure wordt uitgevoerd. De broneditor markeert de geteste code. U kunt de resultaten exporteren in populaire indelingen zoals Cobertura.

Eisen

De codedekkingsfunctie is alleen beschikbaar in Visual Studio Enterprise Edition.

Notitie

Voor .NET-codedekking kunt u ook het opdrachtregelprogramma dotnet-coveragegebruiken.

Codedekking analyseren

1. Selecteer in het menu TestenCodedekking analyseren voor alle tests.

   

   Fooi

   U kunt ook codedekking uitvoeren vanuit de tool-venster Test Explorer.

2. Nadat de tests zijn uitgevoerd, kiest u Codedekkingskleuring weergeven in het venster Codedekkingsresultaten. Standaard wordt code die door tests wordt gedekt gemarkeerd in lichtblauw.

   

   In de vervolgkeuzelijst voor de optie Codedekkingskleuring weergeven kunt u selecteren of de kleuring van toepassing is op regels code, glyphs in de linkermarge of beide.

3. Als u de kleuren wilt wijzigen of vetgedrukte tekst wilt gebruiken, kiest u Extra>Opties>Omgeving>Lettertypen en kleuren>Toon instellingen voor: Teksteditor. Pas onder Weergave-itemsinstellingen aan voor de items 'Dekking', bijvoorbeeld 'Dekking niet-aangeraakt gebied'.

   

4. Als de resultaten lage dekking tonen, onderzoekt u welke onderdelen van de code niet worden uitgevoerd en schrijft u meer tests om deze te dekken. Ontwikkelteams streven doorgaans naar ongeveer 80% codedekking. In sommige situaties is een lagere dekking acceptabel. Een lagere dekking is bijvoorbeeld acceptabel wanneer bepaalde code wordt gegenereerd op basis van een standaardsjabloon.

Fooi

Codedekking optimaliseren:

• Optimalisatie van compiler uitschakelen.
• Als u werkt met niet-beheerde (systeemeigen) code, gebruikt u een foutopsporingsbuild.
• Genereer .pdb (symbool) bestanden voor elke assemblage.

Als u de verwachte resultaten niet krijgt, raadpleegt u Problemen met de codedekking oplossen.

Vergeet niet om de codedekking opnieuw uit te voeren na het bijwerken van uw code. Dekkingsresultaten en codekleuring worden niet automatisch bijgewerkt nadat u de code hebt gewijzigd of wanneer u tests uitvoert.

Tip

Vanaf Visual Studio 2022 versie 17.2 kunt u de nieuwste functies voor codedekking inschakelen door Extra > Opties > Omgeving > Preview-functies te selecteren, en vervolgens verbeteringen in de dekking van code te selecterenen Vervolgens Visual Studio opnieuw te starten.

Het rapport in blokken of lijnen

Codedekking wordt geteld in blokken. Een blok is een deel van de code met precies één ingangs- en uitpunt. Als de besturingsstroom van het programma tijdens een testuitvoering een blok doorloopt, wordt dat blok als gedekt beschouwd. Het aantal keren dat het blok wordt gebruikt, heeft geen invloed op het resultaat.

U kunt de resultaten ook weergeven voor rijen door Kolommen toevoegen/verwijderen te kiezen in de tabelkop. Sommige gebruikers geven de voorkeur aan een aantal regels, omdat de percentages nauwkeuriger overeenkomen met de grootte van de fragmenten die u in de broncode ziet. Een lang berekeningsblok telt als één blok, zelfs als het veel regels in beslag neemt.

Fooi

Een coderegel kan meer dan één codeblok bevatten. Als dit het geval is en de testuitvoering alle codeblokken in de regel uitvoert, wordt deze geteld als één regel. Als sommige, maar niet alle codeblokken in de regel worden gebruikt, wordt deze geteld als een gedeeltelijke regel.

Weergaven met resultaten van codedekking

Het venster codedekkingsresultaten structureert meestal het rapport in de project-/klasse-/methodehiërarchie. U kunt dit wijzigen om de dekking weer te geven op map-/bestand/methodeniveau.

• Als u het bronrapportwilt weergeven, selecteert u het pictogram Codedekkingsweergaven configureren in het venster Resultaten van codedekking. Selecteer vervolgens in de vervolgkeuzelijst voor Rapportstijl de optie bronweergave.

In het venster codedekkingsresultaten wordt meestal het resultaat voor de hele oplossing weergegeven. De resultaten kunnen worden gefilterd om alleen maar de resultaten weer te geven voor de bestanden die zijn bijgewerkt in de huidige tak.

• Als u hetvan het wijzigingensetrapport wilt weergeven, selecteert u het pictogram Codedekkingsweergaven configureren in het venster Resultaten van codedekking. Selecteer vervolgens Wijzigingensetrapport in de vervolgkeuzelijst Rapportinhoud. Werk de actieve opslagplaats en de basisvertakking bij zodat het een vergelijkingsrapport kan leveren.

In het zoekvak in het venster Code Coverage Resultaten zijn er verschillende manieren om het rapport te filteren.

• Als u wilt zoeken op naam (alleen de items weergeven die overeenkomen met de zoekreeks in het venster), voert u de zoekreeks in het zoekvak in.
• Als u wilt filteren op type typt u de naam van het type in het zoekvak.
• Om alle weer te geven, maakt u het zoekvak leeg.
• Als u 100% volledig bedektewilt weergeven, voert u 'Gedekt (%Lines)':'100' in het zoekvak in.
• Als u wilt weergeven (>0% && < 100%) gedeeltelijk gedekt, voert u 'Gedeeltelijk gedekt (%Lines)':'<##' in en vervangt u ## door het percentage dat wordt gedekt.
• Als u 0%wilt weergeven, voert u 'Niet gedekt (%Lines)':'0' in het zoekvak in.

Resultaten van codedekking beheren

In het venster codedekkingsresultaten wordt meestal het resultaat van de meest recente uitvoering weergegeven. De resultaten variëren als u uw testgegevens wijzigt of als u slechts enkele van uw tests elke keer uitvoert.

Het venster codedekkingsresultaten kan ook worden gebruikt om eerdere resultaten weer te geven, of resultaten die op andere computers zijn verkregen.

U kunt de resultaten van verschillende uitvoeringen samenvoegen, bijvoorbeeld van uitvoeringen die verschillende testgegevens gebruiken.

• Als u een eerdere set resultatenwilt weergeven, selecteert u deze in de vervolgkeuzelijst. In het menu wordt een tijdelijke lijst weergegeven die wordt gewist wanneer u een nieuwe oplossing opent.

• Als u resultaten van een vorige sessiewilt bekijken, kiest u Resultaten importeren, gaat u naar de map TestResults in uw oplossing en importeert u een .dekkingsbestand.

  De dekkingskleuring is mogelijk onjuist als de broncode is gewijzigd sinds het .dekkingsbestand is gegenereerd.

• Als u resultaten leesbaar wilt maken als tekst, kiest u Resultaten exporteren, selecteert u .xml als Opslaan als. Hiermee wordt een leesbaar .xml bestand gegenereerd, dat u met andere hulpprogramma's kunt verwerken of eenvoudig in e-mail kunt verzenden. U kunt ook exportindelingen selecteren, zoals Cobertura.

• Als u resultaten wilt verzenden naar iemand anders, verzendt u een .dekkingsbestand of een geëxporteerd .xml-bestand. Vervolgens kunnen ze het bestand importeren. Als ze dezelfde versie van de broncode hebben, kunnen ze dekkingskleuring zien.

Resultaten van verschillende uitvoeringen samenvoegen

In sommige situaties worden verschillende blokken in uw code gebruikt, afhankelijk van de testgegevens. Daarom wilt u de resultaten van verschillende testuitvoeringen combineren.

Stel dat als je een test uitvoert met invoer "2", je merkt dat 50% van een bepaalde functie wordt gedekt. Wanneer u de test een tweede keer uitvoert met de invoer -2, ziet u in de dekkingskleurweergave dat de andere 50% van de functie wordt behandeld. Nu voegt u de resultaten van de twee testuitvoeringen samen en in de kleurenweergave voor rapporten en dekking ziet u dat 100% van de functie is behandeld.

Gebruik om resultaten samen te voegen om dit te doen. U kunt elke combinatie van recente uitvoeringen of geïmporteerde resultaten kiezen. Als u geëxporteerde resultaten wilt combineren, moet u ze eerst importeren.

Gebruik Resultaten exporteren om de resultaten van een samenvoegbewerking op te slaan.

Beperkingen bij samenvoegen

• Als u dekkingsgegevens uit verschillende versies van de code samenvoegt, worden de resultaten afzonderlijk weergegeven, maar worden ze niet gecombineerd. Als u volledig gecombineerde resultaten wilt ophalen, gebruikt u dezelfde build van de code en wijzigt u alleen de testgegevens.

• Als u een resultatenbestand samenvoegt dat is geëxporteerd en vervolgens wordt geïmporteerd, kunt u alleen de resultaten weergeven op regels, niet op blokken. Gebruik de opdracht Kolommen toevoegen/verwijderen om de lijndata weer te geven.

• Als u resultaten van tests van een ASP.NET project samenvoegt, worden de resultaten voor de afzonderlijke tests weergegeven, maar niet gecombineerd. Dit gedrag is alleen van toepassing op de ASP.NET artefacten zelf: resultaten voor andere assembly's worden gecombineerd.

Elementen uitsluiten van de resultaten van de codedekking

Mogelijk wilt u specifieke elementen in uw code uitsluiten van de dekkingsscores, bijvoorbeeld als de code wordt gegenereerd op basis van een tekstsjabloon. Voeg het kenmerk System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute toe aan een van de volgende code-elementen: klasse, struct, methode, eigenschap, eigenschapssetter of getter, gebeurtenis.

Fooi

Als u een klasse uitsluit, worden de afgeleide klassen niet uitgesloten.

Bijvoorbeeld:

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

Elementen uitsluiten in systeemeigen C++-code

Niet-beheerde (systeemeigen) elementen uitsluiten in C++-code:

#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)

Gebruik de volgende macro's:

ExcludeFromCodeCoverage( UitsluitingsNaam, L"FunctieNaam");

ExcludeSourceFromCodeCoverage( ExclusionName, L"SourceFilePath");

• ExclusionName is een unieke naam.

• FunctionName is een volledig gekwalificeerde functienaam. Het kan jokertekens bevatten. Als u bijvoorbeeld alle functies van een klasse wilt uitsluiten, schrijft u MyNamespace::MyClass::*

• SourceFilePath- is het lokale of UNC-pad van een .cpp-bestand. Het kan jokertekens bevatten. In het volgende voorbeeld worden alle bestanden in een bepaalde map uitgesloten: \\MyComputer\Source\UnitTests\*.cpp

• #include <CodeCoverage\CodeCoverage.h>

• Plaats aanroepen naar de uitsluitingsmacro's in de globale naamruimte, niet binnen een naamruimte of klasse.

• U kunt de uitsluitingen plaatsen in het unittestcodebestand of in het toepassingsbestand.

• De uitsluitingen moeten worden gecompileerd als onbeheerde (systeemeigen) code, ofwel door de compileroptie in te stellen of door #pragma managed(off)te gebruiken.

Notitie

Als u functies wilt uitsluiten in C++/CLI-code, past u het kenmerk toe [System::Diagnostics::CodeAnalysis::ExcludeFromCodeCoverage] op de functie. Dit is hetzelfde als voor C#.

Aanvullende elementen opnemen of uitsluiten

Codedekkingsanalyse wordt alleen uitgevoerd op assembly's die worden geladen en waarvoor een .pdb--bestand beschikbaar is in dezelfde map als het bestand .dll of .exe. Daarom kunt u in bepaalde omstandigheden de set opgenomen assembly's uitbreiden door kopieën van de juiste .pdb--bestanden te verkrijgen.

U kunt meer controle uitoefenen over welke assembly's en elementen zijn geselecteerd voor codedekkingsanalyse door een .runsettings--bestand te schrijven. U kunt bijvoorbeeld assembly's van bepaalde soorten uitsluiten zonder dat u kenmerken aan hun klassen hoeft toe te voegen. Zie Analyse van codedekking aanpassenvoor meer informatie.

Codedekking analyseren in Azure Pipelines

Wanneer u uw code incheckt, worden uw tests uitgevoerd op de buildserver, samen met tests van andere teamleden. Het is handig om codedekking in Azure Pipelines te analyseren om de meest up-to-datum en uitgebreide afbeelding van dekking in het hele project te krijgen. Codedekking in Azure Pipelines omvat ook geautomatiseerde systeemtests en andere gecodeerde tests die u meestal niet uitvoert op de ontwikkelcomputers.

Codedekking analyseren vanaf de opdrachtregel

Als u tests vanaf de opdrachtregel wilt uitvoeren, gebruikt u het hulpprogramma vstest.console.exe. Codedekking is een optie van het vstest.console.exe hulpprogramma dat wordt aangeroepen door /EnableCodeCoverage optie.

1. Start de opdrachtprompt voor Ontwikkelaars voor Visual Studio:

   Zoek in het menu Start van Windows naar en selecteer het app-resultaat dat is gekoppeld aan uw zoektekst.

2. Voer bij de opdrachtprompt de volgende opdracht uit:

   vstest.console.exe MyTestAssembly.dll /EnableCodeCoverage
   

   Tip

   Voor Developer PowerShell is de beginmap van de shell de Locatie van het Visual Studio-project. Vervang MyTestAssembly.dll door de pad- en testbestandsnaam. Zie VSTest.Console.exe opdrachtregeloptiesvoor meer informatie.

Problemen oplossen

Als u geen resultaten van de codedekking ziet, kan het Problemen met codedekking oplossen artikel u mogelijk helpen.

Verwante inhoud

• Analyse van codedekking aanpassen
• Problemen met codedekking oplossen
• eenheid uw code testen