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

Pour déterminer la proportion de code de votre projet qui sera testée par des tests codés, par exemple des tests unitaires, recourez à la fonctionnalité de couverture du code de Visual Studio. Pour apporter une protection efficace contre les bogues, vos tests doivent s’effectuer sur ou « couvrir » une proportion importante 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 dans le menu Test lorsque vous exécutez des méthodes de test à l’aide de l’Explorateur de tests. La table des résultats affiche le pourcentage de code exécuté dans chaque assembly, classe et procédure. L’éditeur de code source met en évidence le code testé. Vous pouvez exporter les résultats dans des formats populaires tels que Cobertura.

Configuration requise

La fonctionnalité de couverture du code n’est disponible que dans l’édition Visual Studio Enterprise.

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 de l’outil Explorateur de tests.

2. Une fois les tests exécutés, pour voir quelles lignes ont été exécutées, choisissez Afficher la couleur de couverture du code dans la fenêtre Résultats de 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 coloration de la couverture du code, vous pouvez choisir si la coloration s’applique aux lignes de code, aux glyphes dans la marge de gauche ou aux deux.

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

   

   

4. Si les résultats indiquent une couverture basse, recherchez les parties du code qui ne sont pas testées, puis élaborez d’autres 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 inférieure est acceptable. Par exemple, une couverture inférieure est acceptable lorsqu'un code est généré à partir d'un modèle standard.

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 de réexécuter la couverture du code après la mise à jour de votre code. Les résultats de couverture et la coloration du code ne sont pas automatiquement mis à jour après avoir la modification de votre code ou lorsque vous exécutez des tests.

Rapport pour les blocs ou les lignes

La couverture du code est mesurée en blocs. Un bloc est un fragment de code avec un seul point d’entrée et de sortie. Si le flux de contrôle du programme traverse un bloc pendant une série de tests, ce bloc est considéré comme couvert. Le nombre de fois où le bloc est utilisé n’a aucun effet sur le résultat.

Les résultats peuvent également être affichés en termes de lignes si vous choisissez Ajouter/supprimer des colonnes dans l’en-tête du tableau. Certains utilisateurs préfèrent un nombre de lignes, car les pourcentages correspondent mieux à la taille des fragments que vous voyez dans le code source. Un long bloc de calcul serait considéré comme un seul bloc même s'il occupe plusieurs lignes.

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 les 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 séries, par exemple les résultats de séries qui utilisent des données de test différentes.

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

• Pour afficher les résultats d’une session antérieure, choisissez Importer les résultats de la couverture du code, 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 été modifié depuis que le fichier .coverage a été généré.

• Pour afficher les résultats sous forme de texte, choisissez Exporter les résultats de la couverture du code. Un fichier .coveragexml lisible est généré. Vous pouvez le traiter avec d’autres outils ou l’envoyer facilement par courrier électronique. Vous pouvez également sélectionner des formats d’exportation tels que Cobertura.

• Pour envoyer les résultats à une autre personne, envoyez un fichier .coverage ou un fichier .coveragexml exporté. Cela permet ensuite à la personne d'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 certains cas, différents blocs de votre code seront utilisés, en fonction des données de test. Par conséquent, vous pouvez souhaiter combiner les résultats des plusieurs séries de tests.

Supposons par exemple que, lorsque vous exécutez un test avec l'entrée « 2 », vous constatez que 50 % d'une fonction spécifique est couvert. Si vous exécutez le test une deuxième fois avec l'entrée « -2 », la deuxième moitié de la fonction apparaît couverte dans la vue avec coloration de la couverture. 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 %.

Pour cela, utilisez Fusionner les résultats de la couverture du code. Vous pouvez choisir n'importe quelle combinaison de séries 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 de la couverture du code pour enregistrer les résultats d’une opération de fusion.

Limitations lors de la fusion

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

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

• Si vous fusionnez les résultats des tests d’un projet ASP .NET, les résultats des tests distincts sont affichés, mais ils ne sont pas combinés. Ce comportement s’applique uniquement aux artefacts ASP .NET eux-mêmes : les résultats de tous les autres assemblys sont 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 à partir des notes 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 aux éléments de code suivants : classe, struct, méthode, propriété, setter ou getter de propriété, événement.

Par exemple :

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

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

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

#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 suivante :

ExcludeFromCodeCoverage( ExclusionName , L" FunctionName ");

ExcludeSourceFromCodeCoverage( ExclusionName , L" SourceFilePath ");

• NomExclusion est un nom unique.

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

• CheminFichierSource 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 les appels aux macros d'exclusion dans l'espace de noms global, et non dans un espace de noms ou dans une classe.

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

• Les exclusions doivent être compilées en tant que code non managé (natif), en définissant l'option du compilateur ou à l'aide de #pragma managed(off).

Inclure ou exclure des éléments supplémentaires

L’analyse de la couverture du code est exécuté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 type particulier sans devoir ajouter des attributs à leurs classes. Pour plus d’informations, consultez Personnaliser l’analyse de la couverture du code.

Analyse de la couverture du code dans Azure Pipelines

Lorsque vous archivez votre code, vos tests s’exécutent sur le serveur de builds, avec les tests des 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 comporte également des tests système automatisés et d’autres tests codés qui ne sont généralement pas exécutés sur les ordinateurs de développement.

Analyser la couverture du code depuis la ligne de commande

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

1. Lancez l’Invite de commandes développeur pour Visual Studio :

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

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

   vstest.console.exe MyTestAssembly.dll /EnableCodeCoverage
   

   Conseil

   Pour PowerShell développeur, le répertoire de départ 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.

Dépanner

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 la couverture du code
• Résoudre les problèmes liés à la couverture du code
• Tests unitaires de votre code