Vue d'ensemble des tests unitaires

Mise à jour : novembre 2007

Les tests unitaires sont des tests de programmation écrits en Visual C# ou Visual Basic, ou en Visual C++ et compilés avec /clr:safe.

Remarque :
Pour plus d'informations sur l'utilisation des tests unitaires avec le code de production C++ et sur l'utilisation des tests unitaires écrits en C++, consultez Tests unitaires et C++.

Les tests unitaires sont utilisés pour tester d'autres codes source en appelant directement les méthodes d'une classe, en passant les paramètres appropriés. Si vous incluez ensuite des instructions Assert, celles-ci peuvent tester les valeurs générées par rapport aux valeurs attendues. Les méthodes de test unitaire résident dans des classes de tests, qui sont stockées dans des fichiers de code source.

Vous pouvez créer des tests unitaires à l'aide d'une fonctionnalité de génération de code qui crée le code source initial du test, ou vous pouvez écrire le test entièrement à la main. Dans les deux cas, la classe de test et toutes les méthodes de test sont identifiées à l'aide d'attributs de programmation.

Chaque classe de test est marquée avec l'attribut [TestClass()]. Chaque test unitaire est une méthode de test qui est marquée avec l'attribut [TestMethod()]. Ces attributs sont assignés automatiquement lorsque des tests unitaires sont générés ; lorsque vous codez des tests unitaires manuellement, vous devez ajouter des attributs de classe et de méthode vous-même. Pour plus d'informations, consultez Structure de tests unitaires.

Génération de tests unitaires

Vous pouvez générer des tests unitaires à l'aide d'une boîte de dialogue accessible par le biais des fenêtres d'outils de Visual Studio. Chaque test unitaire est créé comme méthode C#, Visual Basic ou Visual C++. Son code et ses attributs résident dans un fichier source dans un projet de test du même langage. Le nouveau test cible le code spécifique que vous souhaitez tester. Vous pouvez générer un seul test unitaire pour une méthode, plusieurs tests pour les méthodes que vous sélectionnez ou plusieurs tests pour toutes les méthodes d'une classe ou d'un espace de noms.

Vous pouvez générer des tests unitaires à partir d'un code source dans votre projet actuel. Vous pouvez également générer des tests unitaires à partir d'un assembly dans le système de fichiers, ce qui est utile lorsque le code source est non disponible.

Le code d'un test généré récemment est compilé, mais pour qu'il puisse fournir des résultats de tests utiles, vous devez le modifier. Par exemple, vous pouvez le modifier pour faire des assignations de variables et pour personnaliser des instructions Assert. Les tests unitaires générés contiennent des instructions TODO qui indiquent quelles lignes de code doivent être modifiées.

Remarque :

Les Outils de test Team System utilisent des conventions d'affectation de noms lors de la génération des tests unitaires. Par exemple, un fichier de test est nommé en concaténant le mot « Test » avec le nom du fichier qui contient le code testé ; par exemple, « Class1Test.cs ». Les noms des classes de tests et des méthodes de test sont générés également à partir de valeurs par défaut. Vous pouvez modifier ces valeurs par défaut dans la boîte de dialogue Configuration de la Génération de Test, que vous pouvez ouvrir en cliquant sur Configurer dans la boîte de dialogue Génération de Test Unitaire.

Pour plus d'informations, consultez Comment : générer un test unitaire.

Création de tests unitaires

Vous pouvez également créer un test unitaire manuellement, sans utiliser la fonctionnalité de génération. Le meilleur moyen de procéder consiste à ajouter un test unitaire à un projet de test ; cela crée une méthode de test à stub qui ne contient aucun code mais à laquelle l'attribut [TestMethod()] est appliqué. Pour terminer le test, vous devez ensuite le modifier dans son fichier source, qui lui-même réside dans un projet de test dans votre solution. Pour plus d'informations, consultez Comment : créer un test unitaire et Structure de tests unitaires.

Infrastructure de test unitaire

L'Infrastructure de test unitaire fournit de nombreuses classes Assert supplémentaires et d'autres classes qui vous procurent une flexibilité dans l'écriture de tests unitaires. Pour plus d'informations, consultez la documentation sur l'espace de noms et les types de Infrastructure de test unitaire sous Microsoft.VisualStudio.TestTools.UnitTesting.

Héritage de classe de test

Une classe de test peut être n'importe quelle classe marquée avec l'attribut TestClass. Les classes de test peuvent à présent hériter de membres d'autres classes de test. Cela signifie que vous pouvez créer des tests réutilisables dans les classes de test de base ; les classes de test dérivées peuvent hériter de tests des classes de test de base. Cette fonctionnalité élimine le code de test dupliqué et offre davantage de flexibilité aux développeurs pendant le test unitaire du code de production.

Une classe de test ne peut pas hériter d'une classe qui se trouve dans un assembly différent. Vous pouvez contourner cette limite de la manière suivante :

1. Définissez votre classe de test de base dans un fichier de code source et ajoutez le fichier au projet A.

2. Ajoutez le même fichier de code source à un projet différent, le projet B. Pour ce faire, cliquez avec le bouton droit sur le projet dans l'Explorateur de solutions, puis sur Ajouter et sur Élément existant, puis utilisez la boîte de dialogue Ajouter un élément existant pour sélectionner le fichier.

3. Bien que le projet B s'intègre dans un assembly différent, il inclut la classe de test de base. D'autres classes de test du projet B peuvent hériter de cette classe de test de base.

Exemple d'héritage

Votre code de production a deux implémentations : l'une utilise un back end Microsoft SQL Server, l'autre utilise Oracle. Les deux implémentations doivent fonctionner de la même façon. Vous pouvez créer une classe de test abstraite nommée DBTestSuite contenant le code de test standard. Vous pouvez créer ensuite deux classes, SQLTestSuite et OracleTestSuite dérivant toutes deux de DBTestSuite. Les classes dérivées doivent implémenter uniquement la méthode Connect abstraite. Une classe de test se connectera ensuite à Microsoft SQL Server et l'autre à Oracle.

En outre, vous pouvez créer une classe de test EmptySQLTestSuite qui dérive de SQLTestSuite pour tester une base de données Microsoft SQL Server vide. Pour améliorer la performance, vous pouvez substituer les méthodes de test particulières qui n'ont aucun sens pour tester une base de données vide.

Si vous utilisez l'héritage de classe de test, la fenêtre Affichage de tests et l'Explorateur de tests affichent les méthodes de test dans les classes de base et dans les classes enfants. Pour voir dans quelle classe se trouve un test, affichez les colonnes Nom de classe ou Nom complet de la classe dans l'Explorateur de tests. Pour plus d'informations, consultez Comment : personnaliser des affichages de tests.

Test de méthodes privées

Les tests unitaires vous permettent de tester non seulement les méthodes publiques, mais aussi les méthodes privées. Comme avec les méthodes publiques, les tests unitaires pour les méthodes privées sont créés automatiquement lorsque vous générez des tests à partir du code que vous souhaitez tester. Pour plus d'informations, consultez Comment : tester une méthode privée et Utilisation d'accesseurs private.

Types particuliers de tests unitaires

Le tableau suivant répertorie les types supplémentaires de tests unitaires :

Voir aussi

Concepts

Structure de tests unitaires

Tests unitaires et C++

Utilisation de tests unitaires pilotés par des données

Autres ressources

Utilisation des tests unitaires ASP.NET

Utilisation des tests unitaires Smart Device

Gestion de tests

Exécution des tests

Analyse des résultats des tests