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

Pour déterminer la proportion de code de votre projet qui sera réellement testée par les tests codés comme tests unitaires, recourez à la fonctionnalité de couverture du code de Visual Studio.Pour être protéger efficacement des bogues, les tests doivent s'effectuer ou « couvrir» une importante proportion de votre code.

L'analyse de couverture du code peut être appliquée au code géré (CLI) et non managé (natif).

La couverture du code est une option 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 méthode.En outre, l'éditeur de code source vous indique quel code a été testé.

Configuration requise

• Visual Studio Ultimate, Visual Studio Premium

Pour analyser la couverture du code sur les tests unitaires dans l'explorateur de tests

1. Dans le menu Test, choisissez analysez la couverture du code.

2. Pour connaître les lignes qui ont été exécutées, choisissez Afficher la coloration de couverture du code.

   Pour modifier les couleurs, ou utiliser le caractère gras, choisissez Outils, Options, Environnement, Polices et couleurs, Paramètres pour: Éditeur de texte.Sous Éléments affichés, ajustez les éléments de couverture.

3. Si les résultats affichent la couverture basse, recherchez les parties du code qui ne sont pas testées, puis entrez d'autres tests pour les couvrir.Les équipes de développement visent généralement une couverture de code qui avoisinne 80%.Dans certaines situations, une couverture inférieure est acceptable.Par exemple, une couverture inférieure est acceptable où un code est généré à partir d'un modèle standard.

Conseil
Pour obtenir des résultats exacts : Assurez -vous que l'optimisation du compilateur est désactivée. Si vous travaillez avec le code natif (non managé), utilisez une version debug. Assurez -vous que vous générez des fichiers de symboles (.pdb) pour chaque assembly. Si vous n'obtenez pas les résultats que vous attendiez, consultez Dépannage de la couverture du code.

Rapport dans les blocs ou les lignes

La couverture du code est numérotée dans les 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 abordé.Le nombre de fois où le bloc est utilisé n'a aucun effet sur le résultat.

Vous pouvez également avoir les résultats affichés en termes de lignes en choisissant Ajouter/supprimer des colonnes dans l'en-tête du tableau.Si la série de tests exerçait tous les blocs de code dans n'importe quelle ligne de code, il est numérotée comme une ligne.Où une ligne contient des blocs de code qui ont été exercés et une partie qui ne l'étaient pas, il est compté comme ligne partielle.

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 compterait comme un seul bloc même s'il occupe plusieurs lignes.

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

La fenêtre Résultats de la couverture du code permet généralement d'avoir le résultat de la série le plus récent.Les résultats varient si vous modifiez les tests, ou si vous exécutez uniquement certains de vos tests à chaque fois.

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

Vous pouvez fusionner les résultats de plusieurs séries, par exemple les exécutions qui utilisent des tests de données.

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

• Pour afficher les résultats d'une session précédente, choisissez Résultats de la couverture du code d'importation, naviguez vers le dossier TestResults dans votre solution, et importent 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 rendre des résultats lisibles sous forme de texte, choisissez Résultats de la couverture du code d'exportation.Cela génère un fichier lisible .coveragexml que vous pouvez traiter avec d'autres outils ou facilement envoyer par courrier.

• Pour envoyer les résultats à quelqu'un d'autre, envoyer un fichier .coverage ou un fichier exporté .coveragexml.Ils peuvent ensuite importer le fichier.S'ils ont la même version de code source, ils peuvent afficher la coloration de couverture.

Fusion des résultats des différents passes

Dans certains cas, des blocs de votre code seront utilisés en fonction des tests.Par conséquent, vous pouvez combiner les résultats des 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 couvert.Lorsque vous exécutez le test une deuxième fois avec l'entrée "-2", pouv pouvez constater dans la vue de coloration de couverture que l'autre 50% de la fonction est couvert.Maintenant, vous fusionnez les résultats de deux séries de tests, et le rapport et la vue d'état et de coloration de couverture montre que la fonction a été couverte à 100%.

Utilisez Résultats de la couverture du code de fusion pour le faire.Vous pouvez choisir toute les combinaisons de passe récentes ou des résultats importés.Si vous souhaitez combiner des résultats exportés, vous devez d'abord les importer.

Utilisez Résultats de la couverture du code d'exportation 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 associés.Pour obtenir un combiné de résultats complet, utilisez la même version du code généré, cela modifiera uniquement les tests.

• Si vous fusionnez les résultats d'un fichier qui a été exportée puis importé, vous pouvez consulter les résultats par lignes, pas 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 associés.Cela s'applique uniquement aux artefacts ASP.NET eux-mêmes : les résultats de tous les autres assemblies sont combinés.

Exclusion d'éléments des résultats de la couverture du code

Vous pouvez exclure des éléments spécifiques dans votre code 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.ExcludeFromCodeCoverage à chacun des éléments de code : classe, structure, méthode, propriété, accesseur Set de propriété ou accesseur Get, événement.Notez que l'exclusion d'une classe n'exclut pas ses classes dérivées.

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

Exclusion d'éléments en code C++ natif

Pour exclure les éléments (natifs) non managés 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 la macro suivante :

-
ExcludeFromCodeCoverage(ExclusionName, L"FunctionName");

ExcludeSourceFromCodeCoverage(ExclusionName, L"SourceFilePath");

• ExclusionName est un nom unique.

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

• SourceFilePath correspond aux variables locales ou au chemin d'accès UNC d'un fichier .cpp.Il peut contenir des caractères génériques.L'exemple suivant exclut tous les fichiers dans 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 tout espace de noms ou classe.

• Vous pouvez définir ces exclusions dans le fichier de code de test unitaire ou dans le fichier de code de l'application.

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

[!REMARQUE]

Pour exclure des fonctions dans C++/CLI code, appliquez l'attribut [System::Diagnostics::CodeAnalysis::ExcludeFromCodeCoverage] à la fonction.La taille est la même que pour C#.

Incluant ou excluant les éléments supplémentaires

L'analyse de couverture du code est exécutée uniquement sur les assemblies chargés et pour laquelle un fichier .pdb est disponible dans le même répertoire que le fichier .dll ou .exe.Par conséquent, dans certaines circonstances, vous pouvez étendre le jeu d'assemblies inclus lors de l'obtention des copies des fichiers appropriés .pdb.

Vous pouvez effectuer davantage de contrôle sur les assemblies et les éléments qui sont sélectionnés pour l'analyse de couverture du code en écrivant un fichier .runsettings.Par exemple, vous pouvez exclure des assemble des types particuliers sans devoir ajouter des attributs à leurs classes.Pour plus d'informations, consultez Personnalisation de l'analyse de couverture du code.

L'analyse de la couverture du code dans le service de build

Lorsque vous archivez votre code, vos tests s'exécutent sur le serveur de builds, ainsi que tous les autres tests des autres membres de l'équipe.(Si vous n'avez pas déjà établi cela, consultez Exécuter des tests dans votre processus de génération.) Il est utile d'analyser la couverture du code sur le service de build, car cela donne l'image la plus récente et la plus complète de la couverture du projet entier.Il inclut également les tests système automatisés et d'autres tests codés que vous n'exécutez généralement pas sur les ordinateurs de développement.

1. Dans Team Explorer, ouvrez Builds, puis ajouter ou modifier une définition de build.

2. Dans la page Processus , développez Tests automatisés, Source de test, Paramètres d'exécution.Définissez Type du fichier de paramètres d'exécution à Couverture du code activée.

   Si vous avez plusieurs définitions de source de test, répétez cette étape pour chaque définitions.

   • Mais il n'y a aucun champ nommé Type du fichier de paramètres d'exécution.

     Sous Tests automatisés, sélectionnez Examinez l'assembly et choisissez le bouton de sélection [...] à la fin de la ligne.Dans la boîte de dialogue Ajoutez/Editez l'exécution de tests , sous Test Runner, choisissez Visual Studio Test Runner.

Après l'exécution de la build, les résultats de la couverture du code sont liés à la série de tests et s'affichent dans le résumé de la build.

L'analyse de la couverture du code dans une ligne de commande

Pour exécuter des tests à partir de la ligne de commande, utilisez vstest.console.exe.La couverture du code est une option de cet utilitaire.Pour plus d'informations, consultez Options de ligne de commande VSTest.Console.exe.

1. Exécutez l'invite de commande de développement Visual Studio :

   Dans le menu Windows Démarrer, choisissez Tous les programmes, Microsoft Visual Studio, Visual Studio Tools, Invite de commandes de développement.

2. Exécuter :

   vstest.console.exe MyTestAssembly.dll /EnableCodeCoverage

Dépannage

Si vous ne voyez pas les résultats de la couverture du code, consultez Dépannage de la couverture du code.

Ressources externes

Aide

Tester pour la Livraison Continue avec Visual Studio 2012 – Chapître 2 : Test Unitaire : Tester l'Intérieur

Voir aussi

Concepts

Personnalisation de l'analyse de couverture du code

Dépannage de la couverture du code

Vérification du code à l'aide de tests unitaires