C #. Exemple de création d'un test unitaire dans MS Visual Studio

1. Le contenu
2. Exécution
3. 2. Préparation du texte du module Program.cs
4. 2.2. Rendre publique la classe du programme
5. 3. Liste du programme testé
6. 4. Créer un test
7. 4.1. Ajout d'un nouveau projet à la solution
8. 4.2. Structure de la solution
9. 4.3. Le texte du fichier "UnitTest1.cs". Attributs [TestMethod] et [TestClass]
10. 4.4. Modification du texte du module UnitTest1. Changer le nom de la méthode de test
11. 4.5 Connexion du projet MinApp au projet TestMinApp
12. 4.6. Apporter des modifications au texte du module UnitTest1.cs
13. 4.6.2. Texte de la méthode TestMin ()
14. 4.7. UnitTest1.cs texte du module
15. 5. Lancer le test et vérifier le résultat du test
16. 6. Le résultat Interaction entre projets

Cette rubrique décrit le processus pas à pas de la création d'un test unitaire simple dans Microsoft Visual Studio 2010 (C #) pour une application telle que l'application console. En utilisant cet exemple, vous pouvez apprendre à créer vos propres tests unitaires. L'exemple montre également l'utilisation de la classe Assert pour tester le fonctionnement des fonctions.

Le contenu

La condition du problème

Pour une application telle que Console Application, développez un test unitaire qui teste le fonctionnement de la fonction Min (), qui détermine l'élément maximal de trois nombres.

Pour la fonction Min (), définissez la méthode de test sur TestMin (). Vérifiez la fonction.

Exécution

1. Créez une application à l'aide du modèle Console Applicaiton

Exécutez MS Visual Studio 2010. Pour créer un projet à l'aide du modèle d'application console, vous devez appeler la séquence de commandes suivante:

Fichier -> Nouveau -> Projet ...

En conséquence, la fenêtre Nouveau projet s'ouvre. Dans la fenêtre, sélectionnez le modèle d'application console, comme indiqué dans la figure 1. Le modèle est sélectionné dans l'onglet Visual C #.

Visual C # -> Application console

Fig. 1. Fenêtre "Nouveau projet". Choix d'une application du type d'application de console

2. Préparation du texte du module Program.cs

2.1. Ajouter la fonction Min () au texte du module

Dans le corps de la classe Program, ajoutez le texte de la fonction Min ().

La fonction est déclarée comme publique (statique) et publique. Texte de la fonction Min ()

public static int Min (int a, int b, int c) {int min = a; si (min> b) min = b; si (min> c) min = c; retour min; }

Fig. 2. Vue de la fenêtre MS Visual Studio 2010, module “Program.cs”

2.2. Rendre publique la classe du programme

Pour avoir accès à la fonction Min () de la classe Program, vous devez rendre cette classe accessible au public. Pour cela, avant de déclarer une classe, vous devez définir le mot clé public.

... namespace MinApp {public class Programme {// méthodes de classe // ...}} ...

Après cela, le programme de test est prêt.

3. Liste du programme testé

Pour le moment, la liste du programme testé est la suivante:

en utilisant le système; using System.Collections.Generic; using System.Linq; using System.Text; namespace MinApp {public class Programme {public static int Min (int, int b, int c) {int min = a; si (min> b) min = b; si (min> c) min = c; retour min; } static void Main (string [] args) {Console.WriteLine ("Démo du test unitaire en C #."); }}}

Puisque ce programme sera testé à partir d'un autre module de test, il n'est pas nécessaire d'entrer autre chose dans la fonction Main (). En raison des conditions du problème, vous devez tester le fonctionnement de la fonction Min (). Et cela sera fait à partir du module de test. Pour le moment, notre programme est prêt pour les tests.

4. Créer un test

Le test est créé par un projet séparé (Projet) dans la solution (Solution). Le programme testé ne le sait pas. Le programme qui va tester (le programme de test) appellera les fonctions du programme testé. Dans notre cas, le programme de test appellera la fonction

int Min (int, int, int);

4.1. Ajout d'un nouveau projet à la solution

Pour cette solution (Solution), vous devez ajouter un nouveau projet à l'aide de la commande

Fichier-> Ajouter-> Nouveau projet ...

La fenêtre permettant de créer un nouveau projet est illustrée à la figure 3.

Fig. 3. Fenêtre pour créer un projet de type Test Project

Un groupe de modèles Visual C # -> Test est sélectionné dans la fenêtre. Parmi les modèles affichés, le modèle de projet «Test Project» est sélectionné. Dans le champ "Nom", le nom du projet qui testera notre programme est indiqué. Vous devez définir, par exemple, TestMinApp. Le projet se trouve dans un dossier séparé "E: \ Test \ MinApp".

Fig. 4. Le texte du module UnitTest1.cs. Fenêtre de l'utilitaire Solution Explorer avec les projets TestMinApp et MinApp affichés

4.2. Structure de la solution

Comme le montre la figure 4, l’utilitaire Solution Explorer affiche la structure Éléments de solution, qui contient deux projets:

• projet MinApp. Il s'agit d'un projet créé à l'aide du modèle d'application de console avec la fonction Min () que vous souhaitez contester.
• Projet TestMinApp. Ce projet est conçu pour tester les fonctionnalités du projet MinApp. Le code de programme qui teste la fonction Min () sera entré dans le fichier de projet UnitTest1 du projet TestMinApp.

Les deux projets peuvent être réalisés indépendamment l'un de l'autre.

4.3. Le texte du fichier "UnitTest1.cs". Attributs [TestMethod] et [TestClass]

Dans le projet TestMinApp, le fichier de test UnitTest1.cs présente un intérêt primordial. Ce fichier contient des méthodes qui testeront les fonctions du projet MinApp. Le projet TestMinApp peut contenir un nombre quelconque de fichiers contenant des tests (par exemple, UnitTest2.cs, UnitTest3.cs, etc.).

La liste du fichier UnitTest1.cs générée par MS Visual Studio 2010 est la suivante:

en utilisant le système; using System.Text; using System.Collections.Generic; using System.Linq; using Microsoft.VisualStudio.TestTools.UnitTesting; namespace TestMinApp {/// <summary> /// Description du résumé de UnitTest1 /// </ summary> [TestClass] Classe publique UnitTest1 {public UnitTest1 () {// // TODO: Ajoutez la logique du constructeur ici //} private TestContext testContextInstance; /// <summary> /// Obtient ou définit le contexte de test. /// </ summary> public TestContext TestContext {get {return testContextInstance; } set {testContextInstance = valeur; }} #region Attributs de test supplémentaires // vous pouvez utiliser vos tests // // Utiliser ClassInitialize // [ClassInitialize ()] // public static void MyClassInitialize (TestContext testContext) {} // // Utiliser ClassCleanup pour exécuter le code une fois que tous les tests d'une classe ont été exécutés // [ClassCleanup ()] // void statique public MyClassCleanup () {} // // Utiliser TestInitialize pour exécuter le code avant chaque test // [[TestInitialize ()] // public void MyTestInitialize () {} // // Utilisez TestCleanup pour exécuter le code après l'exécution de chaque test // [TestCleanup ()] // public void MyTestCleanup ( ) {} // #endregion [TestMethod] public void TestMethod1 () {// // TODO: Ajoutez la logique de test ici //}}}

Comme le montre le code ci-dessus, le fichier contient une classe nommée UnitTest1. La classe a une méthode publique appelée TestMethod1 (). Avant d'implémenter la méthode TestMethod1 (), l'attribut [TestMethod] est placé. Cela signifie que vous devez entrer le code qui testera les fonctions du projet MinApp dans le corps de la méthode.

Dans la classe, vous pouvez entrer autant de méthodes que vous souhaitez pour tester différentes fonctions de différents modules. L'essentiel est que ces méthodes soient marquées avec l'attribut [TestMethod].

4.4. Modification du texte du module UnitTest1. Changer le nom de la méthode de test

Vous pouvez modifier les noms des méthodes et ajouter de nouvelles méthodes marquées de l'attribut [TestMethod] dans le module UnitTest1.cs. Compte tenu de cela, dans le texte du module UnitTest1.cs, vous devez renommer la méthode TestMethod1 () en TestMin ().

Une fois les modifications apportées, le texte abrégé du module du fichier UnitTest1.cs sera:

en utilisant le système; using System.Text; using System.Collections.Generic; using System.Linq; using Microsoft.VisualStudio.TestTools.UnitTesting; namespace TestMinApp {/// <summary> /// Description du résumé de UnitTest1 /// </ summary> [TestClass] classe publique UnitTest1 {... [TestMethod] public void TestMin () {// TODO: Ajouter un test la logique ici //}}}

4.5 Connexion du projet MinApp au projet TestMinApp

Pour avoir accès à la fonction Min () (projet MinApp) à partir du projet TestMinApp, vous devez vous connecter à l'espace de noms dans lequel se trouve cette fonction.

Pour ce faire, vous devez tout d’abord appeler le menu contextuel du projet TestMinApp. Ensuite, dans le menu contextuel, vous devez appeler la commande «Ajouter une référence ...» (Figure 5).

Fig. 5. L’équipe «Ajouter une référence ...»

En conséquence, la fenêtre Ajouter une référence s'ouvre, dans laquelle vous devez sélectionner le projet MinApp.

Fig. 6. Fenêtre "Ajouter une référence". Connecter le projet MinApp

Une fois les actions terminées, les fonctions du projet MinApp seront disponibles pour une utilisation dans le projet TestMinApp.

Fig. 7. Onglet Références avec le projet MinApp connecté

4.6. Apporter des modifications au texte du module UnitTest1.cs

4.6.1. Ajout de l'espace de noms MinApp au module UnitTest1.cs

A cette étape, dans le module UnitTest1.cs, vous devez ajouter l'espace de nom MinApp à l'aide de la directive using:

en utilisant le système; using System.Text; using System.Collections.Generic; using System.Linq; using Microsoft.VisualStudio.TestTools.UnitTesting; en utilisant MinApp; espace de noms TestMinApp {...}

4.6.2. Texte de la méthode TestMin ()

Dans le texte de la méthode TestMin (), entrez le code suivant:

... [TestMethod] public void TestMin () {// // TODO: Ajoutez la logique de test ici // int min; min = programme min (3, 4, 5); Assert .EreEqual (2, min); } ...

4.7. UnitTest1.cs texte du module

Le texte de l'ensemble du module UnitTest1.cs est le suivant:

en utilisant le système; using System.Text; using System.Collections.Generic; using System.Linq; using Microsoft.VisualStudio.TestTools.UnitTesting; en utilisant MinApp; namespace TestMinApp {/// <summary> /// Description du résumé de UnitTest1 /// </ summary> [TestClass] Classe publique UnitTest1 {public UnitTest1 () {// // TODO: Ajoutez la logique du constructeur ici //} private TestContext testContextInstance; /// <summary> /// Obtient ou définit le contexte de test. /// </ summary> public TestContext TestContext {get {return testContextInstance; } set {testContextInstance = valeur; }} #region Attributs de test supplémentaires // vous pouvez utiliser vos tests // // Utiliser ClassInitialize // [ClassInitialize ()] // public static void MyClassInitialize (TestContext testContext) {} // // Utiliser ClassCleanup pour exécuter le code une fois que tous les tests d'une classe ont été exécutés // [ClassCleanup ()] // void statique public MyClassCleanup () {} // // Utiliser TestInitialize pour exécuter le code avant chaque test // [[TestInitialize ()] // public void MyTestInitialize () {} // // Utilisez TestCleanup pour exécuter le code après l'exécution de chaque test // [TestCleanup ()] // public void MyTestCleanup ( ) {} // #endregion [TestMethod] public void TestMin () {// // TODO: Ajoutez la logique de test ici // int min; min = programme min (3, 4, 5); Assert .EreEqual (2, min); }}}

5. Lancer le test et vérifier le résultat du test

Dans Microsoft Visual Studio 2010, un menu spécial de commandes appelé Test est implémenté pour l'utilisation des tests unitaires.

Pour exécuter un test d'exécution, sélectionnez l'une des commandes.

ou

Test -> Exécuter -> Tous les tests de la solution

comme le montre la figure 8.

Fig. 8. Appelez la commande start test et affichez le résultat.

Une fois le test exécuté, vous pouvez afficher le résultat au bas de la fenêtre Résultats du test. Comme on peut le voir sur la figure, le test n'est pas réussi. C'est logique, car dans la fonction Assert.AreEqual (), nous comparons les nombres 2 et 3, qui sont différents. Ici, le numéro 2 est spécialement introduit au lieu de 3.

Si, au lieu du numéro 2, vous entrez la réponse correcte - numéro 3 (minimum compris entre 3, 4 et 5), le test sera réussi (Figure 9). Dans ce cas, le texte de la méthode TestMin () sera le suivant:

... [TestMethod] public void TestMin () {// // TODO: Ajoutez la logique de test ici // int min; min = programme min (3, 4, 5); Assert .EreEqual (3, min); } ...

La fenêtre de résultat est illustrée à la figure 9.

Fig. 9. Résultat du test pour le cas, si vous entrez la bonne réponse

Nous pouvons maintenant conclure que la fonction Min () pour ce cas fonctionne correctement.

6. Le résultat Interaction entre projets

Dans cet article, deux projets sont formés dans la solution. Un projet MinApp contient la fonction Min () que vous souhaitez tester. Le second projet, TestMinApp, contient des méthodes de test.

Dans Microsoft Visual Studio 2010, chaque projet est lancé à l'aide de différentes commandes de menu. Ainsi, le projet MinApp est lancé de manière standard à partir du menu Exécuter. Et le projet TestMinApp est lancé à partir du menu Test spécial.

Sujets connexes