Test unitaires

Les tests dans le développement.

L'activité de test est très importante dans le développement. Tester c'est vérifier que l'application réalise bien son cahier des charges. Mais si l'on veut tester les fonctionalités attendues il faut commencer par faire des tests dès les premières méthodes (ou fonctions) écrites. Cette dernière activité porte un nom : les tests unitaires. Un test unitaire est un test portant sur une seule méthode.

Depuis quelques années, les tests sont systématisés, le temps mis pour les mettre au point étant largement compensé par la valeur ajoutée en terme de fiabilité du code produit.

Des méthodes de conception proposent même une vision originale de la place du test dans le cycle de développement. Ainsi les méthodes dites "agiles" ( voir http://www.rad.fr/puma.htm ), qui excellent plutôt dans le domaine des projets RAD (Rapide Application Developpement), proposent de faire des tests un point d'entrée des activités de développement (FirstTest : tests en premier!)

Afin d'industrialiser la pratique de test, les frameworks (Java, Php, Dotnet) proposent des environnement logiciels facilitant grandement cette activité. Nous allons utiliser NUnit qui propose ce type de service pour DotNet.

1. Installation de NUnit.

Téléchargez le fichier .msi ( http://www.nunit.org/download.html ) , installez le.

En lançant l'application, on trouve l'interface du produit NUnit :

fig 1 NUnit

2. Mise en oeuvre dans Visual Studio

Nous allons tester la classe Alea, utilisée dans le TP 421 :

public class Alea : Random
{
       private Alea(){}
       public static Alea Instance()
        {
               if (MonAlea == null)
                       MonAlea = new Alea();
               return MonAlea;
         }
        public int Nouveau(int valMin,int valMax)
        {
                  return base.Next(valMin,valMax+1);
         }
         public int Nouveau(int valMax)
         {
                  return base.Next(valMax+1);
          }
         private static Alea MonAlea=null;
}

Commentaires :

  • Cette classe hérite de la classe Random du Framework
  • Cette classe permet de créer une instance unique.
  • Les méthodes surchargées Nouveau calculent une nouvelle valeur aléatoire.

Lançons une application WinForm avec Visual Studio, appelons MonAlea le projet.

  1. Ajouter une classe dans le projet, nommer le fichier Alea.cs :


                                                                fig 2 ajout de la classe Alea au projet
     

  2. Remplacer le code de la classe Alea généré par le code recopié plus haut.
     
  3. Ajouter une référence au FrameWork NUnit :


                                                                             fig 3 ajout de référence au projet
     

  4. Ajouter dans le projet la classe, TestAlea, qui va être utilisée pour les tests :

fig 4. Ajout de la classe test dans Visual Studio

Commentaires :

  • Ne pas oublier la clause using
  • Les attributs obligatoires (TestFixture et Test) permettent au FrameWork d'identifier les objets qui vont être analysés pour bénéficier de ses services
  • La méthode TestUnicite est ajoutée ici, elle sera développée plus loin.

3. Les tests avec NUnit

NUnit utilise une classe principale Assert, composée de méthodes statiques. Ces méthodes testent une "assertion" (une proposition) et vont générer un test valide ou pas selon le résultat.

Nous allons commencer par tester l'unicité de l'instance retournée pas la méthode statique Instance(). Pour cela il suffit de comparer l'égalité de deux instances construites. Ecrivons le code de la méthode TestUnicite :

[TestFixture] // attribut à ajouter avant chaque classe de test
public class TestAlea
{
          [Test] // attribut à ajouter avant chaque méthode à tester
          public void TestUnicite()
          {
                 Alea a1 = Alea.Instance();
                 Alea a2 = Alea.Instance();
                 Assert.AreEqual(a1,a2);
           }
}

 

  1. Compiler le projet :

    Les tests ne peuvent s'effectuer que sur des projets compilés (Générer/Générer la solution).
     

  2. Lancer NUnit et ouvrir le fichier monAlea.exe :


                         fig 5 chargement du projet dans NUnit

     

  3. Lancer l'exécution (bouton Run)


                                                                                       fig 6 lancement du test et réussite

    Le test est réussi !!

Commentaire :

La méthode Assert.AreEqual(a1,a2), cf plus haut, a posé l'assertion que les deux objets étaient identiques, le test est ainsi validé

Si nous avions fait l'assertion contraire Assert.AreNotEqual(a1,a2), le test échouait (ne pas oublier de compiler) :

.

                                                                           fig 7 échec du test

    4. Autres tests

Nous allons tester la méthode Nouveau(int) pour sa valeur maximum :

[Test]
public void TestValeurMax()
{
         Alea a1 = Alea.Instance();
         int n = a1.Nouveau(0);
        Assert.AreEqual(n,0);
}

En fait ici nous vérifions que si la valeur maximum est 0, le nombre aléatoire retourné est bien 0 :

                                                          fig 8 test de la valeur maximum

Remarque : si nous omettons de faire figurer l'attribut [Test], NUnit ignore la méthode.

Pour terminer, nous allons tester la méthode Nouveau(int valMin,int valMax) dans ses valeurs de bornes :

[Test]
public void TestBornes()
{
      Alea a1 = Alea.Instance();
      int n=a1.Nouveau(2,9);
     Assert.IsTrue(n>=2 && n<=9);
}

Commentaire : la méthode statique IsTrue prend ici comme paramètre une expression booléenne

fig 9. test des bornes de la variable aléatoire

D'autres méthodes statiques sont disponibles, qu'il n'est pas nécessaire de commenter davantage :

  • IsNull
  • IsNotNull
  • IsFalse
  • ...