Tutoriel : Tester une bibliothèque de classes .NET

Ce tutoriel montre comment automatiser les tests unitaires en ajoutant un projet de test à une solution.

Prerequisites

Ce didacticiel fonctionne avec la solution que vous créez dans Créer une bibliothèque de classes .NET.

Créer un projet de test unitaire

Les tests unitaires fournissent des tests logiciels automatisés pendant votre développement et votre publication. MSTest est l’une des trois infrastructures de test parmi lesquelles vous pouvez choisir. Les autres sont xUnit et nUnit.

Démarrez Visual Studio.
Ouvrez la solution ClassLibraryProjects que vous avez créée dans Créer une bibliothèque de classes .NET.
Ajoutez un nouveau projet de test unitaire nommé « StringLibraryTest » à la solution.
1. Cliquez avec le bouton droit sur la solution dans Explorateur de solutions et sélectionnez Add> Nouveau projet.
2. Dans la page Ajouter un nouveau projet, entrez mstest dans la zone de recherche. Choisissez C# ou Visual Basic dans la liste des langues, puis choisissez Toutes les plateformes dans la liste des plateformes.
3. Choisissez le modèle Projet de test MSTest, puis choisissez Suivant.
4. Sur la page Configurer votre nouveau projet, entrez StringLibraryTest dans la zone Nom du projet. Ensuite, choisissez Suivant.
5. Dans la page Additional information, sélectionnez .NET 10 dans la zone Framework, sélectionnez Microsoft.Testing.Platform pour l’exécuteur Test, puis choisissez Create.
Entrez des informations supplémentaires pour le projet de test MSTest
Visual Studio crée le projet et ouvre le fichier de classe dans la fenêtre de code avec le code suivant. Si la langue que vous souhaitez utiliser n’est pas affichée, modifiez le sélecteur de langue en haut de la page.
```
namespace StringLibraryTest
{

    [TestClass]
    public sealed class Test1
    {
        [TestMethod]
        public void TestMethod1()
        {
        }
    }
}
```
```
Imports Microsoft.VisualStudio.TestTools.UnitTesting

Namespace StringLibraryTest
    <TestClass>
    Public Class Test1
        <TestMethod>
        Sub TestSub()

        End Sub
    End Class
End Namespace
```
Le code source créé par le modèle de test unitaire effectue les opérations suivantes :
- Inclut Microsoft.VisualStudio.TestTools.UnitTesting dans le fichier projet StringLibraryTest en C#, et importe Microsoft.VisualStudio.TestTools.UnitTesting dans Visual Basic.
- Applique l’attribut à la classe.
- Applique l’attribut TestMethodAttribute pour définir TestMethod1 en C# ou TestSub dans Visual Basic.
Chaque méthode marquée avec [TestMethod] dans une classe de test marquée avec [TestClass] s’exécute automatiquement lorsque le test unitaire s’exécute.

Démarrez Visual Studio Code.
Ouvrez la solution ClassLibraryProjects que vous avez créée dans Créer une bibliothèque de classes .NET.
À partir de Explorateur de solutions, sélectionnez New Project ou, dans la palette de commandes, sélectionnez .NET : Nouveau projet.
Sélectionnez MSTest Test Project, nommez-le « StringLibraryTest », sélectionnez le répertoire par défaut, puis sélectionnez Créer un projet.

Le modèle de projet crée StringLibraryTest/Test1.cs avec le code suivant :
```
namespace StringLibraryTest;

[TestClass]
public class Test1
{
    [TestMethod]
    public void TestMethod1()
    {
    }
}
```
Le code source créé par le modèle de test unitaire effectue les opérations suivantes :
- Il applique l’attribut à la classe.
- Il applique l'attribut pour définir.
- Il importe l’espace de noms, qui contient les types utilisés pour les tests unitaires. L’espace de noms est importé via une directive dans GlobalUsings.cs.
Chaque méthode marquée avec [TestMethod] dans une classe de test marquée avec [TestClass] est exécutée automatiquement lorsque le test unitaire est appelé.

Ouvrez le terminal et accédez au dossier des didacticiels contenant les projets StringLibrary et ShowCase.
Créez un projet de test MSTest :
```
dotnet new mstest -n StringLibraryTest
```
Le modèle de projet crée StringLibraryTest/Test1.cs avec le code suivant :
```
namespace StringLibraryTest;

[TestClass]
public class Test1
{
    [TestMethod]
    public void TestMethod1()
    {
    }
}
```
Le code source créé par le modèle de test unitaire effectue les opérations suivantes :
- Il applique l’attribut à la classe.
- Il applique l’attribut pour définir .
- Il importe l’espace de noms, qui contient les types utilisés pour les tests unitaires.
Chaque méthode marquée avec [TestMethod] dans une classe de test marquée avec [TestClass] est exécutée automatiquement lorsque le test unitaire est appelé.

Ajouter une référence de projet

Pour que le projet de test fonctionne avec la classe, ajoutez une référence dans le projet au projet.

Dans Explorateur de solutions, cliquez avec le bouton droit sur le projet Dependencies du StringLibraryTest et sélectionnez Add Project Reference dans le menu contextuel.
Dans la boîte de dialogue Gestionnaire de références , sélectionnez la zone en regard de StringLibrary.

Ajoutez StringLibrary en tant que référence de projet pour StringLibraryTest.
Cliquez sur OK.

À partir de Explorateur de solutions cliquez avec le bouton droit sur le projet « StringLibraryTest », puis sélectionnez Add Project Reference.
Sélectionnez « StringLibrary ».

Accédez au dossier StringLibraryTest et ajoutez la référence du projet :

cd StringLibraryTest
dotnet add reference ../StringLibrary/StringLibrary.csproj

Ajouter et exécuter des méthodes de test unitaire

Lorsqu’un test unitaire s’exécute, chaque méthode marquée avec l’attribut dans une classe marquée avec l’attribut s’exécute automatiquement. Une méthode de test se termine lorsque le premier échec est trouvé ou lorsque tous les tests contenus dans la méthode réussissent.

Les tests les plus courants appellent des membres de la classe . De nombreuses méthodes d’assertion incluent au moins deux paramètres, dont l’un est le résultat de test attendu et l’autre étant le résultat réel du test. Voici quelques-unes des méthodes les plus fréquemment appelées par la classe :

Méthodes d’assertion	Fonction
`Assert.AreEqual`	Vérifie que deux valeurs ou objets sont égaux. L’assertion échoue si les valeurs ou les objets ne sont pas égaux.
`Assert.AreSame`	Vérifie que deux variables d’objet font référence au même objet. L’assertion échoue si les variables font référence à différents objets.
`Assert.IsFalse`	Vérifie qu’une condition est . L’assertion échoue si la condition est .
`Assert.IsNotNull`	Vérifie qu’un objet n’est pas . L’assertion échoue si l’objet est .

Vous pouvez également utiliser la méthode dans une méthode de test pour indiquer le type d'exception qu'elle est censée lancer. Le test échoue si l’exception spécifiée n’est pas levée.

Lors du test de la méthode, vous souhaitez fournir un certain nombre de chaînes commençant par un caractère majuscule. Vous vous attendez à ce que la méthode retourne dans ces cas, afin de pouvoir appeler la méthode . De même, vous souhaitez fournir un certain nombre de chaînes qui commencent par quelque chose d’autre qu’un caractère majuscule. Vous vous attendez à ce que la méthode retourne dans ces cas, afin de pouvoir appeler la méthode .

Étant donné que votre méthode de bibliothèque gère les chaînes, vous souhaitez également vous assurer qu’elle gère correctement une chaîne vide () et une chaîne. Une chaîne vide est une chaîne qui n’a aucun caractère et dont la valeur est 0. Une chaîne de caractères est celle qui n'a pas été initialisée. Vous pouvez appeler directement en tant que méthode statique et passer un seul argument. Vous pouvez également appeler en tant que méthode d’extension sur une variable affectée à .

Vous allez définir trois méthodes, chacune appelant une méthode pour chaque élément d’un tableau de chaînes. Vous allez appeler une surcharge de méthode qui vous permet de spécifier un message d’erreur à afficher en cas d’échec de test. Le message identifie la chaîne qui a provoqué l’échec.

Pour créer les méthodes de test :

Dans la fenêtre de code Test1.cs ou Test1.vb , remplacez le code par le code suivant :

using UtilityLibraries;

namespace StringLibraryTest
{
    [TestClass]
    public sealed class Test1
    {
        [TestMethod]
        public void TestStartsWithUpper()
        {
            // Tests that we expect to return true.
            string[] words = ["Alphabet", "Zebra", "ABC", "Αθήνα", "Москва"];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsTrue(result, $"Expected for '{word}': true; Actual: {result}");
            }
        }

        [TestMethod]
        public void TestDoesNotStartWithUpper()
        {
            // Tests that we expect to return false.
            string[] words = ["alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                          "1234", ".", ";", " "];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsFalse(result, $"Expected for '{word}': false; Actual: {result}");
            }
        }

        [TestMethod]
        public void DirectCallWithNullOrEmpty()
        {
            // Tests that we expect to return false.
            string?[] words = [string.Empty, null];
            foreach (var word in words)
            {
                bool result = StringLibrary.StartsWithUpper(word);
                Assert.IsFalse(result, $"Expected for '{word ?? "<null>"}': false; Actual: {result}");
            }
        }
    }
}

Imports Microsoft.VisualStudio.TestTools.UnitTesting
Imports UtilityLibraries

Namespace StringLibraryTest
    <TestClass>
    Public Class UnitTest1
        <TestMethod>
        Public Sub TestStartsWithUpper()
            ' Tests that we expect to return true.
            Dim words() As String = {"Alphabet", "Zebra", "ABC", "Αθήνα", "Москва"}
            For Each word In words
                Dim result As Boolean = word.StartsWithUpper()
                Assert.IsTrue(result,
                       $"Expected for '{word}': true; Actual: {result}")
            Next
        End Sub

        <TestMethod>
        Public Sub TestDoesNotStartWithUpper()
            ' Tests that we expect to return false.
            Dim words() As String = {"alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                               "1234", ".", ";", " "}
            For Each word In words
                Dim result As Boolean = word.StartsWithUpper()
                Assert.IsFalse(result,
                       $"Expected for '{word}': false; Actual: {result}")
            Next
        End Sub

        <TestMethod>
        Public Sub DirectCallWithNullOrEmpty()
            ' Tests that we expect to return false.
            Dim words() As String = {String.Empty, Nothing}
            For Each word In words
                Dim result As Boolean = StringLibrary.StartsWithUpper(word)
                Assert.IsFalse(result,
                       $"Expected for '{If(word Is Nothing, "<null>", word)}': false; Actual: {result}")
            Next
        End Sub
    End Class
End Namespace

Le test des caractères majuscules dans la méthode inclut la lettre majuscule grecque alpha (U+0391) et la lettre majuscule cyrillique EM (U+041C). Le test des caractères minuscules dans la méthode inclut la lettre minuscule grecque alpha (U+03B1) et la lettre minuscule cyrillique Ghe (U+0433).

Dans la barre de menus, sélectionnez FichierEnregistrer Test1.cs Sous ou FichierEnregistrer Test1.vb Sous. Dans la boîte de dialogue Enregistrer un fichier sous, sélectionnez la flèche en regard du bouton Enregistrer, puis sélectionnez Enregistrer avec encodage.
Dans la boîte de dialogue Confirmer l’enregistrement sous, sélectionnez le bouton Oui pour enregistrer le fichier.
Dans la boîte de dialogue Options d’enregistrement avancées, sélectionnez Unicode (UTF-8 avec signature) - Page de codes 65001 dans la liste déroulante Encodage, puis sélectionnez OK.

Si vous ne parvenez pas à enregistrer votre code source en tant que fichier encodé en UTF8, Visual Studio pouvez l’enregistrer en tant que fichier ASCII. Dans ce cas, le runtime ne décode pas avec précision les caractères UTF8 en dehors de la plage ASCII et les résultats des tests ne sont pas corrects.
Dans la barre de menus, sélectionnez TestExécuter tous les tests. Si la fenêtre Explorateur de tests ne s’ouvre pas, ouvrez-la en choisissant TestExplorateur de tests. Les trois tests sont répertoriés dans la section Tests réussis, et la section Résumé signale le résultat de l’exécution du test.

fenêtre Explorateur de tests avec réussite de tests

Ouvrez StringLibraryTest/Test1.cs et remplacez tout le code par le code suivant.

using UtilityLibraries;

namespace StringLibraryTest
{
    [TestClass]
    public sealed class Test1
    {
        [TestMethod]
        public void TestStartsWithUpper()
        {
            // Tests that we expect to return true.
            string[] words = ["Alphabet", "Zebra", "ABC", "Αθήνα", "Москва"];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsTrue(result, $"Expected for '{word}': true; Actual: {result}");
            }
        }

        [TestMethod]
        public void TestDoesNotStartWithUpper()
        {
            // Tests that we expect to return false.
            string[] words = ["alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                          "1234", ".", ";", " "];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsFalse(result, $"Expected for '{word}': false; Actual: {result}");
            }
        }

        [TestMethod]
        public void DirectCallWithNullOrEmpty()
        {
            // Tests that we expect to return false.
            string?[] words = [string.Empty, null];
            foreach (var word in words)
            {
                bool result = StringLibrary.StartsWithUpper(word);
                Assert.IsFalse(result, $"Expected for '{word ?? "<null>"}': false; Actual: {result}");
            }
        }
    }
}

Enregistrez vos modifications.

Générer et exécuter vos tests

Dans Explorateur de solutions, cliquez avec le bouton droit sur la solution, puis sélectionnez Build ou dans la palette de commandes, sélectionnez .NET : Générer.
Sélectionnez la fenêtre Test , sélectionnez Exécuter des tests ou dans la palette de commandes, sélectionnez Test : Exécuter tous les tests.

Ouvrez StringLibraryTest/Test1.cs et remplacez tout le code par le code suivant :

using UtilityLibraries;

namespace StringLibraryTest
{
    [TestClass]
    public sealed class Test1
    {
        [TestMethod]
        public void TestStartsWithUpper()
        {
            // Tests that we expect to return true.
            string[] words = ["Alphabet", "Zebra", "ABC", "Αθήνα", "Москва"];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsTrue(result, $"Expected for '{word}': true; Actual: {result}");
            }
        }

        [TestMethod]
        public void TestDoesNotStartWithUpper()
        {
            // Tests that we expect to return false.
            string[] words = ["alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                          "1234", ".", ";", " "];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsFalse(result, $"Expected for '{word}': false; Actual: {result}");
            }
        }

        [TestMethod]
        public void DirectCallWithNullOrEmpty()
        {
            // Tests that we expect to return false.
            string?[] words = [string.Empty, null];
            foreach (var word in words)
            {
                bool result = StringLibrary.StartsWithUpper(word);
                Assert.IsFalse(result, $"Expected for '{word ?? "<null>"}': false; Actual: {result}");
            }
        }
    }
}

Enregistrez vos modifications et exécutez les tests :
```
dotnet test
```
Les tests doivent réussir.

Gérer les échecs de test

Si vous effectuez un développement piloté par les tests (TDD), vous écrivez d’abord des tests et qu’ils échouent la première fois que vous les exécutez. Ensuite, vous ajoutez du code à l’application qui réussit le test. Pour ce tutoriel, vous avez créé le test après avoir écrit le code de l’application qu’il valide, de sorte que vous n’avez pas vu le test échouer. Pour vérifier qu’un test échoue lorsque vous vous attendez à ce qu’il échoue, ajoutez une valeur non valide à l’entrée de test.

Modifiez le tableau dans la méthode pour inclure la chaîne « Error ».

string[] words = { "alphabet", "Error", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                   "1234", ".", ";", " " };

Dim words() As String = { "alphabet", "Error", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                   "1234", ".", ";", " " }

Exécutez le test en sélectionnant TestExécuter tous les tests dans la barre de menus. La fenêtre de l’Explorateur de tests indique que deux tests ont réussi et un échec.

Fenêtre de l'Explorateur de tests avec des tests ayant échoué
Sélectionnez le test ayant échoué, .

La fenêtre de l’Explorateur de tests affiche le message généré par l’assertion : « Assert.IsFalse a échoué. Attendu pour « Erreur » : false ; réel : vrai. À cause de l’échec, les chaînes du tableau après « Erreur » n’ont pas été testées.

fenêtre Explorateur de tests montrant l’échec de l’assertion IsFalse

Exécutez les tests en cliquant sur l’erreur verte en regard du test dans l’éditeur.

La sortie indique que le test échoue et qu’il fournit un message d’erreur pour le test ayant échoué : « Assert.IsFalse a échoué. Attendu pour « Erreur » : faux ; réel : vrai. Aucune chaîne du tableau après « Erreur » n'a été testée en raison de l’échec.

Exécutez les tests :
```
dotnet test
```
La sortie indique que le test échoue et qu’il fournit un message d’erreur pour le test ayant échoué : « Assert.IsFalse a échoué. Attendu pour « Erreur » : faux ; réel : vrai. En raison de l’échec, aucune chaîne du tableau après « Erreur » a été testée.

Supprimez la chaîne « Error » que vous avez ajoutée.
Réexécutez le test et les tests réussissent.

Tester la version Release de la bibliothèque

Maintenant que les tests ont tous réussi lors de l'exécution de la version Debug de la bibliothèque, exécutez les tests une nouvelle fois sur la version Release de la bibliothèque. Un certain nombre de facteurs, y compris les optimisations du compilateur, peuvent parfois produire un comportement différent entre les builds Debug et Release.

Pour tester la build Release :

Dans la barre d’outils Visual Studio, remplacez la configuration de build de Debug par Release.
Dans Explorateur de solutions, cliquez avec le bouton droit sur le projet StringLibrary et sélectionnez Build dans le menu contextuel pour recompiler la bibliothèque.
Exécutez les tests unitaires en choisissant TestExécuter tous les tests à partir de la barre de menus. Les tests sont réussis.

Exécutez les tests avec la configuration de build Release :

dotnet test StringLibraryTest/StringLibraryTest.csproj --configuration Release

Les tests sont réussis.

Exécutez les tests avec la configuration de build Release :

dotnet test --configuration Release

Les tests sont réussis.

Déboguer les tests

Si vous utilisez Visual Studio en tant qu'IDE, vous pouvez utiliser le même processus illustré dans Tutorial : déboguer une application console .NET pour déboguer du code à l'aide de votre projet de test unitaire. Au lieu de démarrer le projet d’application ShowCase, cliquez avec le bouton droit sur le projet StringLibraryTests, puis sélectionnez Déboguer les tests dans le menu contextuel.

Visual Studio démarre le projet de test avec le débogueur attaché. L’exécution s’arrête à tout point d’arrêt que vous avez ajouté au projet de test ou au code de bibliothèque sous-jacent.

Si vous utilisez Visual Studio Code en tant qu'IDE, vous pouvez utiliser le même processus illustré dans Debug a .NET application console pour déboguer du code à l'aide de votre projet de test unitaire. Au lieu de démarrer le projet d’application ShowCase , ouvrez StringLibraryTest/Test1.cs, puis sélectionnez Déboguer les tests dans le fichier actif entre les lignes 7 et 8. Si vous ne parvenez pas à le trouver, appuyez sur Ctrl+Maj+P pour ouvrir la palette de commandes et entrez Recharger la fenêtre.

Visual Studio Code démarre le projet de test avec le débogueur attaché. L’exécution s’arrête à tout point d’arrêt que vous avez ajouté au projet de test ou au code de bibliothèque sous-jacent.

Ressources supplémentaires

notions de base des tests unitaires - Visual Studio
Tests unitaires dans .NET

Test unitaire dans .NET

Nettoyer les ressources

GitHub supprime automatiquement votre Espace de code après 30 jours d’inactivité. Si vous envisagez d’explorer d’autres tutoriels de cette série, vous pouvez laisser votre espace de code provisionné. Si vous êtes prêt à visiter le site .NET pour télécharger le Kit de développement logiciel (SDK) .NET, vous pouvez supprimer votre espace de code. Pour supprimer votre espace de code, ouvrez une fenêtre de navigateur et accédez à vos espaces de code. Vous voyez une liste de vos espaces de code dans la fenêtre. Sélectionnez les trois points () dans l’entrée de l’espace de code du didacticiel Learn. Sélectionnez ensuite « Supprimer ».

Prochaines étapes

Dans ce tutoriel, vous avez effectué le test unitaire d’une bibliothèque de classes. Vous pouvez rendre la bibliothèque accessible à d’autres utilisateurs en la publiant sur NuGet en tant que package. Pour en savoir plus, suivez un didacticiel NuGet :

Créer et publier un package à l’aide de l’interface CLI dotnet

Si vous publiez une bibliothèque en tant que package NuGet, d’autres peuvent l’installer et l’utiliser. Pour en savoir plus, suivez un didacticiel NuGet :

Installer et utiliser un package à l’aide de l’interface CLI dotnet

Une bibliothèque ne doit pas être distribuée en tant que package. Il peut être regroupé avec une application console qui l’utilise. Pour savoir comment publier une application console, consultez le didacticiel précédent de cette série :

Publier une application console .NET

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-03-06

Partager via

Tutoriel : Tester une bibliothèque de classes .NET

Prerequisites

Créer un projet de test unitaire

Ajouter une référence de projet

Ajouter et exécuter des méthodes de test unitaire

Générer et exécuter vos tests

Gérer les échecs de test

Tester la version Release de la bibliothèque

Déboguer les tests

Ressources supplémentaires

Nettoyer les ressources

Prochaines étapes

Commentaires

Ressources supplémentaires