Cette rubrique décrit le processus étape par étape de création du test unitaire le plus simple dans Microsoft Visual Studio 2010 (C#) pour l’application Console. En utilisant cet exemple, vous pouvez apprendre à créer vos propres tests unitaires. L’exemple montre également comment utiliser la classe Assert pour les tests.

Contenu

  • Tâche
  • Instructions
    • 1. Créez une application à l’aide du modèle d’application Console
    • 2. Préparation du texte du programme.module cs
      • 2.1. Ajout de la fonction Min()
      • 2.2. Rendre la classe du programme publique
    • 3. Liste du programme testé
    • 4. Création d’un test
      • 4.1. Ajout d’un nouveau projet à la solution
      • 4.2. Structure de la solution
      • 4.3. Code de programme de « UnitTest1.fichier cs ». Attributs et
      • 4.4. Apporter des modifications au texte UnitTest1.module cs. Changement du nom de la méthode d’essai
      • 4.5. Connexion du projet MinApp au projet TestMinApp
      • 4.6. Modification de l’UnitTest1.texte du module cs
        • 4.6.1. Ajout de l’espace de noms MinApp à UnitTest1.cs
        • 4.6.2. Texte de la méthode TestMin()
      • 4.7. Le texte de UnitTest1.module cs
    • 5. Exécutez le test et vérifiez le résultat du test
    • 6. Résultat. Interaction entre les projets
  • Rubriques connexes

Rechercher d’autres sites Web :

Tâche

Pour une application de type Application Console, développez un test unitaire qui teste la fonction Min(). Pour la fonction Min(), définissez la méthode de test TestMin(). Testez le résultat des fonctions.

Instructions

1. Créez une application à l’aide du modèle d’application Console

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:

File -> New -> Project...

En conséquence, la nouvelle fenêtre de projet s’ouvre. Dans la fenêtre, sélectionnez le modèle « Application Console » comme indiqué à la figure 1. Le modèle est sélectionné dans l’onglet Visual C#.

 C #. Formulaires Windows. La fenêtre "Nouveau projet". Sélection de l

Figure 1. La fenêtre « Nouveau projet ». Sélection de l’application  » Console »

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

2.1. En ajoutant la fonction Min()

Dans le corps de la classe de programme, vous devez ajouter le texte de la fonction Min(). La fonction est déclarée publique et statique. Le texte de la fonction Min()

 C #. La fenêtre MS Visual Studio, le module "Programme.c"

Figure 2. La fenêtre MS Visual Studio, le module « Programme.c »

2.2. Rendre la classe de programme publique

Pour accéder à la fonction Min() de la classe de programme, vous devez rendre cette classe publique. Pour ce faire, avant la déclaration de classe, vous devez définir le mot clé public.

...namespace MinApp{ public class Program { // методы класса // ... }}...

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

3. Liste du programme testé

Pour le moment, le code du programme testé est le suivant:

using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace MinApp{ public class Program { public static int Min(int a, int b, int c) { int min = a; if (min > b) min = b; if (min > c) min = c; return min; } static void Main(string args) { Console.WriteLine("Demo of Unit-testing in C#."); } }}

Parce que ce programme sera testé à partir d’un autre module de test, alors dans la fonction Main(), vous n’avez pas besoin de taper autre chose. Puisque, conformément à l’état de la tâche, vous devez tester le fonctionnement de la fonction Min(). Et cela sera déjà fait à partir du module de test. Pour le moment, notre programme est prêt à être testé.

4. Création d’un test

Le test est créé par un projet distinct dans la Solution. Le programme que vous testez ne le sait pas. Le programme de test qui testera appelle les fonctions du programme en cours de 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, un nouveau projet est ajouté à l’aide de la commande

File->Add->New Project...

La fenêtre de création d’un nouveau projet est illustrée à la figure 3.

 C #. Application de formulaires Windows. La fenêtre de création d'un projet de type Test Project

Figure 3. La fenêtre de création d’un projet de type Test Project

Dans la fenêtre, vous devez sélectionner le groupe de modèles

Visual C# -> Test

Parmi les modèles affichés, le modèle de projet « Projet de test » est sélectionné. Le champ « Nom » indique le nom du projet qui testera notre programme. Vous devez définir, par exemple, TestMinApp. Le projet se trouve dans un dossier séparé « E:\Test\MinApp « .

 C #. Les "Unités1.fichier cs". La fenêtre de l

Figure 4. Les « Unités1.fichier cs ». La fenêtre de l’Explorateur de solutions avec les projets TestMinApp et MinApp affichés

4.2. Structure de la Solution

Comme vous pouvez le voir sur la Figure 4, l’Explorateur de solutions affiche la structure des éléments de solution, qui contient deux projets:

  • le projet MinApp. Il s’agit d’un projet créé à l’aide du modèle « Application Console » avec la fonction Min() à tester ;
  • le projet TestMinApp. Ce projet est conçu pour tester les fonctions du projet MinApp. Le code du programme qui teste la fonction Min() sera ajouté au fichier de projet UnitTest1 du projet TestMinApp.

Les deux projets peuvent être exécutés indépendamment l’un de l’autre.

4.3. Code de programme de « UnitTest1.fichier cs ». Attributs et

Dans le projet TestMinApp, l’UnitTest1.le fichier de test cs est d’intérêt principal. Ce fichier contient des méthodes qui testeront les fonctions du projet MinApp. Le projet TestMinApp peut contenir n’importe quel nombre de fichiers contenant des tests (par exemple, UnitTest2.cs, unités3.cs, etc.).

Code de programme de « UnitTest1.le fichier « cs », généré par MS Visual Studio 2010, est le suivant:

using System;using System.Text;using System.Collections.Generic;using System.Linq;using Microsoft.VisualStudio.TestTools.UnitTesting;namespace TestMinApp{ /// <summary> /// Summary description for UnitTest1 /// </summary> public class UnitTest1 { public UnitTest1() { // // TODO: Add constructor logic here // } private TestContext testContextInstance; /// <summary> ///Gets or sets the test context which provides ///information about and functionality for the current test run. ///</summary> public TestContext TestContext { get { return testContextInstance; } set { testContextInstance = value; } } #region Additional test attributes // // You can use the following additional attributes as you write your tests: // // Use ClassInitialize to run code before running the first test in the class // // public static void MyClassInitialize(TestContext testContext) { } // // Use ClassCleanup to run code after all tests in a class have run // // public static void MyClassCleanup() { } // // Use TestInitialize to run code before running each test // // public void MyTestInitialize() { } // // Use TestCleanup to run code after each test has run // // public void MyTestCleanup() { } // #endregion public void TestMethod1() { // // TODO: Add test logic here // } }}

Comme vous pouvez le voir dans le code ci-dessus, le fichier contient une classe nommée UnitTest1. La classe implique une méthode publique nommée TestMethod1().Avant d’implémenter la méthode TestMethod1(), l’attribut est placé. Cela signifie que dans le corps de la méthode, vous devez écrire du code qui testera les fonctions du projet MinApp.

Dans la classe, vous pouvez entrer n’importe quel nombre de méthodes qui testeront différentes fonctions de différents modules. L’essentiel est que ces méthodes soient remarquées par l’attribut.

4.4. Apporter des modifications au texte UnitTest1.module cs. Modification du nom de la méthode de test

Vous pouvez modifier les noms de méthode et ajouter de nouvelles méthodes marquées avec l’attribut dans l’UnitTest1.module cs. Dans cet esprit, dans UnitTest1.cs, la méthode TestMethod1() doit être renommée en TestMin().

Une fois les modifications apportées, le texte abrégé de UnitTest1.le module de fichier cs ressemblera à:

using System;using System.Text;using System.Collections.Generic;using System.Linq;using Microsoft.VisualStudio.TestTools.UnitTesting;namespace TestMinApp{ /// <summary> /// Summary description for UnitTest1 /// </summary> public class UnitTest1 { ... public void TestMin() { // // TODO: Add test logic here // } }}

4.5. Connexion du projet MinApp au projet TestMinApp

Pour accéder à la fonction Min() (le projet MinApp) à partir du projet TestMinApp, vous devez monter l’espace de noms dans lequel cette fonction est déclarée.

Pour ce faire, vous devez 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).

 C #. Création de tests unitaires. Le "Ajouter une référence..." commande

Figure 5. La commande « Ajouter une référence… »

Par conséquent, la fenêtre « Ajouter une référence » s’ouvre, dans laquelle vous sélectionnez le projet MinApp.

 C #. Test unitaire créant La fenêtre "Ajouter Une Référence". Connexion au projet MinApp

Figure 6. La fenêtre « Ajouter une référence ». Connexion au projet MinApp

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

 C #. Application de formulaires Windows. L

Figure 7. L’onglet « Références » avec le projet MinApp connecté

4.6. Modification de l’UnitTest1.texte du module cs
4.6.1. Ajout de l’espace de noms MinApp à UnitTest1.cs

Dans cette étape, vous devez ajouter l’espace de noms MinApp à UnitTest1.cs utilisant la directive ‘using’:

using System;using System.Text;using System.Collections.Generic;using System.Linq;using Microsoft.VisualStudio.TestTools.UnitTesting;using MinApp;namespace TestMinApp{ ...}

4.6.2. Texte de la méthode TestMin()

Dans le texte de la méthode TestMin(), vous devez entrer le code suivant:

...public void TestMin(){ // // TODO: Add test logic here // int min; min = Program.Min(3, 4, 5); Assert.AreEqual(2, min);}...

4.7. Le texte de UnitTest1.module cs

Le texte de tous les UnitTest1.le module cs est le suivant:

using System;using System.Text;using System.Collections.Generic;using System.Linq;using Microsoft.VisualStudio.TestTools.UnitTesting;using MinApp;namespace TestMinApp{ /// <summary> /// Summary description for UnitTest1 /// </summary> public class UnitTest1 { public UnitTest1() { // // TODO: Add constructor logic here // } private TestContext testContextInstance; /// <summary> ///Gets or sets the test context which provides ///information about and functionality for the current test run. ///</summary> public TestContext TestContext { get { return testContextInstance; } set { testContextInstance = value; } } #region Additional test attributes // // You can use the following additional attributes as you write your tests: // // Use ClassInitialize to run code before running the first test in the class // // public static void MyClassInitialize(TestContext testContext) { } // // Use ClassCleanup to run code after all tests in a class have run // // public static void MyClassCleanup() { } // // Use TestInitialize to run code before running each test // // public void MyTestInitialize() { } // // Use TestCleanup to run code after each test has run // // public void MyTestCleanup() { } // #endregion public void TestMin() { // // TODO: Add test logic here // int min; min = Program.Min(3, 4, 5); Assert.AreEqual(2, min); } }}

5. Exécutez le test et vérifiez le résultat du test

Dans Microsoft Visual Studio 2010 pour les tests unitaires, un menu spécial « Test » est implémenté.

Pour exécuter le test, vous devez sélectionner l’une des commandes

Test -> Run -> Tests in Current Context

ou

Test -> Run -> All Tests in Solution

comme indiqué dans la figure 8.

 C #. Création de tests unitaires. Appel de la commande test et affichage du résultat

Figure 8. Appeler la commande test et afficher le résultat

Après le démarrage du test, le résultat peut être affiché à gauche dans la fenêtre de l’Explorateur de tests. Comme on peut le voir sur la figure 8, 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 entré à la place du numéro 3.

Si, au lieu du numéro 2, vous entrez la bonne réponse – le numéro 3 (minimum entre 3, 4, 5), le test sera soumis (figure 9). Dans ce cas, le texte de la méthode TestMin() sera le suivant:

...public void TestMin(){ // // TODO: Add test logic here // int min; min = Program.Min(3, 4, 5); Assert.AreEqual(3, min);}...

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

 C #. Création de tests unitaires. Résultat du test pour le cas où vous entrez la bonne réponse

Figure 9. Résultat du test pour le cas où vous entrez la bonne réponse

Maintenant, nous pouvons conclure que la fonction Min() fonctionne correctement pour ce cas.

6. Résultat. Interaction entre les projets

Dans cette tâche, la solution implique deux projets. Un projet MinApp contient la fonction Min() à tester. Le deuxième projet TestMinApp contient des méthodes de test. Dans Microsoft Visual Studio 2010, chacun des projets est exécuté à l’aide de différentes commandes de menu. Ainsi, le projet MinApp est exécuté de la manière standard à partir du menu Exécuter. Et le projet TestMinApp est lancé à partir d’un menu spécial « Test ».

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.