Utiliser la couverture du code pour déterminer la quantité de code testée

Pour déterminer la proportion du code de votre projet testée par des tests codés tels que des tests unitaires, vous pouvez utiliser la fonctionnalité de couverture du code de Visual Studio. Pour vous protéger efficacement contre les bogues, vos tests doivent exercer ou « couvrir » une grande proportion de votre code.

L’analyse de la couverture du code est possible pour le code managé (CLR) et non managé (natif). L’instrumentation statique et dynamique est prise en charge. Pour utiliser la couverture du code dans des scénarios de ligne de commande, utilisez vstest.console.exe ou l’outil Microsoft.CodeCoverage.Console, qui est une extension pour dotnet-coverage qui prend également en charge le code natif.

L’option de couverture du code est disponible sous le menu Test lorsque vous exécutez des méthodes de test à l’aide de l’Explorateur de tests. Le tableau des résultats affiche le pourcentage du code exécuté dans chaque assembly, classe et procédure. L’éditeur source met en surbrillance le code testé. Vous pouvez exporter les résultats dans des formats populaires tels que Cobertura.

Exigences

La fonctionnalité de couverture du code est disponible uniquement dans Visual Studio Enterprise Edition.

Remarque

Pour la couverture du code .NET, vous pouvez également utiliser l’outil en ligne de commande dotnet-coverage.

Analyser la couverture du code

1. Dans le menu Test, sélectionnez Analyser la couverture du code pour tous les tests.

   

   Conseil

   Vous pouvez également exécuter la couverture du code à partir de la fenêtre d'outils de l'Explorateur de tests.

2. Une fois les tests exécutés, pour voir quelles lignes ont été exécutées, choisissez Afficher la coloration de la couverture du code dans la fenêtre Résultats de la couverture du code. Par défaut, le code couvert par les tests est mis en surbrillance en bleu clair.

   

   Dans la liste déroulante de l’option Afficher la couleur de couverture du code, vous pouvez choisir si la coloration s’applique aux lignes de code, aux glyphes dans la marge gauche ou aux deux.

3. Pour modifier les couleurs ou utiliser un visage en gras, choisissez Outils>Options>Environnement>Polices et couleurs>Afficher les paramètres pour : Éditeur de texte. Sous Afficher les éléments, ajustez les paramètres des éléments « Couverture », par exemple Zone de couverture non touchée.

   Capture d’écran

4. Si les résultats montrent une faible couverture, examinez quelles parties du code ne sont pas exercées et rédigez plus de tests pour les couvrir. Les équipes de développement visent généralement une couverture de code qui avoisine 80 %. Dans certaines situations, une couverture plus faible est acceptable. Par exemple, une couverture plus faible est acceptable lorsque du code est généré à partir d’un modèle standard.

Conseil

Pour optimiser la couverture du code :

• Désactivez l’optimisation du compilateur.
• Si vous travaillez avec du code non managé (natif), utilisez une version Debug.
• Générez des fichiers .pdb (symbole) pour chaque assembly.

Si vous n’obtenez pas les résultats escomptés, consultez Résoudre les problèmes liés à la couverture du code.

N’oubliez pas d’exécuter à nouveau les tests de couverture après avoir mis à jour votre code. Les résultats de couverture et la coloration du code ne sont pas automatiquement mis à jour après avoir modifié votre code ou lorsque vous exécutez des tests.

Conseil

À compter de Visual Studio 2022 version 17.2, vous pouvez activer les dernières fonctionnalités de couverture du code en sélectionnant Outils > Options > Environnement > Fonctionnalités d’aperçu, puis en sélectionnant améliorations de l’expérience de couverture du code, puis en redémarrant Visual Studio.

Rapport par blocs ou lignes

La couverture du code est mesurée en blocs. Le bloc est une partie du code avec exactement un point d'entrée et un point de sortie. Si le flux de contrôle du programme passe par un bloc pendant une exécution de test, ce bloc est comptabilisé comme couvert. Le nombre de fois où le bloc est utilisé n’affecte pas le résultat.

Vous pouvez également afficher les résultats des lignes en choisissant Ajouter/supprimer des colonnes dans l’en-tête du tableau. Certains utilisateurs préfèrent un nombre de lignes, car les pourcentages correspondent plus étroitement à la taille des fragments que vous voyez dans le code source. Un long bloc de calcul compterait comme un bloc unique même s’il occupe de nombreuses lignes.

Conseil

Une ligne de code peut contenir plusieurs blocs de code. Si c’est le cas, et que l’exécution de test exerce tous les blocs de code dans la ligne, il est compté comme une seule ligne. Si certains blocs de code, mais pas tous les blocs de code de la ligne, sont exercés, il est compté comme une ligne partielle.

Vues des résultats de couverture du code

La fenêtre des résultats de couverture du code structure généralement le rapport selon la hiérarchie projet/classe/méthode. Vous pouvez modifier cette option pour afficher la couverture au niveau répertoire/fichier/méthode.

• Pour afficher le rapport source, sélectionnez l’icône Configurer les vues de couverture du code dans la fenêtre Résultats de la couverture du code. Ensuite, sélectionnez Affichage Source à partir du menu déroulant Style de rapport.

La fenêtre Résultats de la couverture du code affiche généralement le résultat de la série entière. Les résultats peuvent être filtrés pour n'afficher que ceux des fichiers mis à jour dans la branche actuelle.

• Pour afficher le rapport d’ensemble de modifications, sélectionnez l’icône Configurer les vues de couverture du code dans la fenêtre Résultats de la couverture du code. Sélectionnez ensuite Rapport d’ensemble de modifications dans la liste déroulante Contenu du rapport. Mettez à jour le référentiel actif et la branche de base à comparer pour qu’il fournisse le rapport de comparaison.

Dans la zone de recherche de la fenêtre Résultats de la couverture du code, il existe plusieurs façons de filtrer le rapport.

• Pour Rechercher par nom (afficher uniquement celles qui correspondent à la chaîne de recherche dans la fenêtre), entrez la chaîne de recherche dans la zone de recherche.
• Pour Filtrer par type entrez le nom du type dans la zone de recherche.
• Pour Afficher tout, désactivez la zone de recherche.
• Pour Afficher 100 % entièrement couvert, entrez « Covered (%Lines) » : « 100 » dans la zone de recherche.
• Pour Afficher (>0 % && < 100 %) partiellement couvert, saisissez « Partially Covered (%Lines) » : « <## » en remplaçant « ## » par le pourcentage couvert.
• Pour Afficher 0 % couvert, entrez « Not Covered (%Lines) » : « 0 » dans la zone de recherche.

Gérer les résultats de la couverture du code

La fenêtre Résultats de la couverture du code affiche généralement le résultat de la série la plus récente. Les résultats varient si vous modifiez vos données de test ou si vous exécutez uniquement certains de vos tests à chaque fois.

La fenêtre Résultats de couverture du code peut également être utilisée pour afficher les résultats précédents ou des résultats obtenus sur d’autres ordinateurs.

Vous pouvez fusionner les résultats de plusieurs exécutions, par exemple à partir d’exécutions qui utilisent différentes données de test.

• Pour afficher un ensemble précédent de résultats, sélectionnez-le dans le menu déroulant. Le menu affiche une liste temporaire qui est effacée lorsque vous ouvrez une nouvelle solution.

• Pour afficher les résultats d’une session précédente, choisissez Importer des résultats, accédez au dossier TestResults dans votre solution, puis importez un fichier .coverage.

  La coloration de couverture peut être incorrecte si le code source a changé depuis la génération du fichier .coverage.

• Pour rendre les résultats lisibles en tant que texte, choisissez Exporter les résultats, sélectionnez .xml en tant que Enregistrer en tant que type. Cela génère un fichier .xml lisible, que vous pouvez traiter avec d’autres outils ou envoyer facilement dans le courrier électronique. Vous pouvez également sélectionner des formats d’exportation tels que Cobertura.

• Pour envoyer des résultats à une autre personne, envoyez un fichier .coverage ou un fichier de .xml exporté. Ils peuvent ensuite importer le fichier. Si la personne a la même version de code source, elle a accès à la coloration de couverture.

Fusionner les résultats de différentes exécutions

Dans certaines situations, différents blocs de votre code seront utilisés en fonction des données de test. Par conséquent, vous pouvez combiner les résultats de différentes séries de tests.

Par exemple, supposons que lorsque vous exécutez un test avec l’entrée « 2 », vous constatez que 50% d’une fonction particulière est couverte. Lorsque vous exécutez le test une deuxième fois avec l'entrée « -2 », vous constatez dans la vue de coloration de couverture que le reste de la fonction (50 %) est couvert. Fusionnez maintenant les résultats des deux séries de tests. Le rapport et la vue de coloration de couverture indiquent que la fonction a été couverte à 100 %.

Utilisez Fusionner les résultats pour réaliser cela. Vous pouvez choisir n’importe quelle combinaison d’exécutions récentes ou de résultats importés. Si vous souhaitez combiner des résultats exportés, vous devez d’abord les importer.

Utilisez Exporter les résultats pour enregistrer les résultats d’une opération de fusion.

Limitations de fusion

• Si vous fusionnez des données de couverture provenant de différentes versions du code, les résultats sont affichés séparément, mais ils ne sont pas combinés. Pour obtenir des résultats entièrement combinés, utilisez la même build du code, en modifiant uniquement les données de test.

• Si vous fusionnez un fichier de résultats qui a été exporté et importé, vous pouvez uniquement afficher les résultats par lignes, et non par blocs. Utilisez la commande Ajouter/Supprimer des colonnes pour afficher les données de ligne.

• Si vous fusionnez les résultats des tests d’un projet ASP.NET, les résultats des tests distincts sont affichés, mais pas combinés. Ce comportement s’applique uniquement aux artefacts ASP.NET eux-mêmes : les résultats des autres assemblys seront combinés.

Exclure des éléments des résultats de la couverture du code

Vous pouvez exclure des éléments spécifiques dans votre code des scores de couverture, par exemple si le code est généré à partir d’un modèle de texte. Ajoutez l’attribut System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute à l’un des éléments de code suivants : classe, struct, méthode, propriété, property setter ou getter, événement.

Conseil

L’exclusion d’une classe n’exclut pas ses classes dérivées.

Par exemple:

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

Exclure des éléments dans le code C++ natif

Pour exclure des éléments non managés (natifs) dans le code 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)

Utilisez les macros suivantes :

ExcludeFromCodeCoverage(ExclusionName, L"FunctionName");

ExcludeSourceFromCodeCoverage(ExclusionName, L"SourceFilePath");

• NomExclusion est un nom unique.

• FunctionName est un nom de fonction pleinement qualifié. Il peut contenir des caractères génériques. Par exemple, pour exclure toutes les fonctions d’une classe, écrivez MyNamespace::MyClass::*

• SourceFilePath est le chemin local ou UNC d’un fichier .cpp. Il peut contenir des caractères génériques. L’exemple suivant exclut tous les fichiers d’un répertoire particulier : \\MyComputer\Source\UnitTests\*.cpp

• #include <CodeCoverage\CodeCoverage.h>

• Placez des appels aux macros d’exclusion dans l’espace de noms global, et non dans un espace de noms ou une classe.

• Vous pouvez placer les exclusions dans le fichier de code de test unitaire ou dans le fichier de code d’application.

• Les exclusions doivent être compilées en tant que code non managé (natif), soit en définissant l’option du compilateur, soit en utilisant #pragma managed(off).

Remarque

Pour exclure des fonctions dans le code C++/CLI, appliquez l’attribut [System::Diagnostics::CodeAnalysis::ExcludeFromCodeCoverage] à la fonction. Il s’agit de la même chose que pour C#.

Inclure ou exclure des éléments supplémentaires

L’analyse de la couverture du code est effectuée uniquement sur les assemblys chargés et pour lesquels un fichier .pdb est disponible dans le même répertoire que le fichier .dll ou .exe. Par conséquent, dans certains cas, vous pouvez étendre le jeu d’assemblys inclus par l’obtention des copies des fichiers .pdb appropriés.

Vous pouvez mieux contrôler les assemblys et les éléments qui sont sélectionnés pour l’analyse de la couverture du code en écrivant un fichier .runsettings. Par exemple, vous pouvez exclure des assemblys de types particuliers sans avoir à ajouter d’attributs à leurs classes. Pour plus d’informations, consultez Personnaliser l’analyse de la couverture du code.

Analyser la couverture du code dans Azure Pipelines

Lorsque vous archivez votre code, vos tests s’exécutent sur le serveur de build, ainsi que les tests d’autres membres de l’équipe. Il est utile d’analyser la couverture du code dans Azure Pipelines, car cela permet d’obtenir l’image la plus récente et la plus complète possible de la couverture sur la totalité du projet. La couverture du code dans Azure Pipelines inclut également des tests système automatisés et d’autres tests codés que vous n’exécutez généralement pas sur les machines de développement.

Analyser la couverture du code à partir de la ligne de commande

Pour exécuter des tests à partir de la ligne de commande, utilisez vstest.console.exe utilitaire. La couverture du code est une option de l’utilitaire vstest.console.exe appelée par l’option /EnableCodeCoverage.

1. Ouvrez le Developer Command Prompt pour Visual Studio :

   Dans le menu Démarrer Windows, recherchez Developer Command Prompt for VS et sélectionnez le résultat de l’application associé à votre texte de recherche.

2. À l’invite de commandes, exécutez la commande suivante :

   vstest.console.exe MyTestAssembly.dll /EnableCodeCoverage
   

   Conseil

   Pour Developer PowerShell, le répertoire de démarrage de l’interpréteur de commandes est l’emplacement du projet Visual Studio. Remplacez MyTestAssembly.dll par le chemin d’accès et le nom du fichier de test. Pour plus d’informations, consultez Options de ligne de commande VSTest.Console.exe.

Résoudre les problèmes

Si vous ne voyez pas les résultats de la couverture du code, consultez l’article Résoudre les problèmes liés à la couverture du code.

Contenu connexe

• Personnaliser l’analyse de couverture du code
• Résoudre les problèmes liés à la couverture du code
• Tests unitaires sur votre code