Horizon .Net

Un article de phertzog    Pas de commentaires

Le but de ce premier billet est de vous faire partager mes tentatives d’application d’une démarche de développement dirigée par les tests (ou TDD) à un cas simple. Actuellement j’utilise plutôt une démarche « classique » : je réfléchis d’abord à mon problème dans sa globalité, je conçois et j’implémente mon algorithme et seulement ensuite je passe à la phase des tests unitaires.

La démarche et le sujet

Pour cet exercice je me suis forcé à appliquer au plus prêt ce que je pense avoir saisi de la démarche TDD. C’est à dire :

1. Ecrire d’abord un test qui échoue
2. Ecrire le code minimum pour faire passer le test. C’est à dire qu’à chaque étape il ne faut pas anticiper le code pour un test futur.
3. Après chaque modification faite pour passer un nouveau test, il faut prendre du recul et modifier le code afin de le rendre « propre » (ce que je traduis par faire que le code respecte les principes de développement comme le fait de supprimer les répétitions, de s’assurer que chaque classe et méthode à bien une seule responsabilité …).

Pour appliquer ces principe, j’ai choisi de prendre un essai de résolution d’ un petit problème informatique assez simple et connu : la recherche de l’équilibrium. Petit énoncé du sujet pour rappel :

Etant donné une suite d’entier dans un tableau, il faut trouver la position dans le tableau à partir de laquelle la somme des entiers de gauche est égale à la somme des entiers de droite (on ne compte pas la valeur de l’élément pivot). Prenons un exemple :

Soit le tableau A[0]=-7 A[1]=1 A[2]=5 A[3]=2 A[4]=-4 A[5]=3 A[6]=0  les équilibrium possibles sont:
3 => A[0]+A[1]+A[2]=A[4]+A[5]+A[6]
6 => A[0]+A[1]+A[2]+A[3]+A[4]+A[5]=0 et la somme de 0 éléments est aussi égale à 0 (il n’y a pas d’élément au delà de l’indice 6).

Les bases de l’exercice étant posée, passons au vif du sujet : la réalisation d’une méthode qui prend en argument un tableau d’entiers et qui

• renvoie l’équilibrium d’indice le plus bas s’il existe au moins un équilibrium : le fait de retourner l’indice de plus bas niveau est un choix purement arbitraire.

• la valeur -1 si aucun équilibrium n’est trouvé.

Maintenant que le contexte est posé, passons au codage.

Le codage

Nous allons donc créer des tests de plus en plus évolués. A chaque étape je vais présenter le code obtenu pour passer le test.

Cas du tableau « null »

Ce premier cas est totalement trivial. Si on passe un tableau vide à la fonction, elle doit renvoyer -1.
Ecrivons donc ce premier test à l’aide de MS Test (inclus dans la version beta de Visual Studio 2010).

Test 01

[TestMethod()]
        public void Simple_NullArray_NoEquilibrium()
        {
            int[] inputArray = null; 
            int expected = -1; 
            int actual;

            actual = Equilibrium.FindEquilibrium(inputArray);
            
            Assert.AreEqual(expected, actual);            
        }

Le code

Ecrivons maintenant le minimum de code pour faire passer ce test. Ici ma principale difficulté était de ne pas écrire trop de code en anticipant ce qui allait venir.

public class Equilibrium
{
    public static int FindEquilibrium(int[] inputArray)
    {
        return -1;
    }
}

Plus simple que ça, je ne vois pas.

Cas du tableau vide

Cette fois ci nous allons envoyer un tableau vide à la méthode. Comme il n’y a pas d’indice défini, la réponse doit à nouveau être -1. Ecrivons donc le test.

Test 02

[TestMethod()]
public void Simple_EmptyArray_NoEquilibrium()
{
    int[] inputArray = new int[] {};
    int expected = -1;
    int actual;

    actual = Equilibrium.FindEquilibrium(inputArray);

    Assert.AreEqual(expected, actual);
}

Le code

Comme nous avons écris du code robuste ce test passe au la main. Il n’y a pas besoin d’ajouter du code à notre code précédent.

Cas du tableau à 1 élément

Notre prochain cas va s’occuper de traiter un tableau contenant un seul élément. Dans ce cas, la fonction doit retourner 0. En effet à gauche et à droite de l’unique élément il n’y a rien => somme de 0 de chaque coté. On remarquera au passage que le valeur stockée dans le tableau n’a pas d’importance.

Test 03

[TestMethod]        
public void Simple_Array_1_Return_0()
{
    //La valeur réelle de l'élément n'a aucune importance dans ce cas
    int[] inputArray = new int[1] { 1 };
    int expected = 0;
    int actual;

    actual = Equilibrium.FindEquilibrium(inputArray);

    Assert.AreEqual(expected, actual); 
}

Remarque : je n’ai pas voulu mettre un nombre aléatoire dans le tableau car je pense que chaque exécution d’un test doit se comporter de la même manière. Un élément aléatoire risquerait d’introduire un comportement dans lequel le test échouerait de manière non prédictive, ce qui nuit à la confiance accordée aux tests. J’ai donc préféré ajouter un commentaire expliquant que le choix de la valeur 1 n’a pas d’importance dans notre cas.

Cette fois ci notre implémentation ne passe pas le test 03. Il faut donc modifier le code.

Le code

public class Equilibrium
{
    public static int FindEquilibrium(int[] inputArray)
    {
        if ((inputArray == null) || (inputArray.Length == 0))
        {
            return -1;
        }
        else
        {
            return 0;
        }            
    }
}

Nous avons regroupé les cas qui doivent renvoyer -1 et ajouter un else qui retourne 0. Même si nous savons que cette solution est imparfaite, elle convient cependant à tous nos tests et c’est ce que nous gardons à ce stade.

Et la suite …

Pour l’instant nous avons couvert les cas simple. Le prochain billet couvrira de nouveau cas. En attendant ce billet je te laisse, cher lecteur, réfléchir aux tests à rajouter. Tu pourras ainsi également comparer le résultat auquel tu seras arrivé avec mon résultat.

PS : Ceci est mon premier billet, merci de faire preuve d’un peu d’indulgence. Par contre les critiques constructives sur le fond ou la forme sont les bienvenues.

A bientôt

Live long and prosper