1 Introduction

Cet exercice a pour but de :

1. manipuler les classes et les conteneurs ;
2. adopter une démarche TDD (/Test Driven Development/) : coder les tests avant de coder nos fonctions, vérifier que les tests sont faux, écrire le code de nos fonctions et enfin vérifier que nos tests sont désormais corrects.

Pour ce faire, vous allez coder une classe permettant de gérer les polynômes en vous inspirant de Fraction1.cpp, Fraction2.cpp et Fraction3.cpp.

2 Travail à faire

• Appliquez la procédure cmake de ce document au canevas SampleGoogleTest.zip.
• Sans vous lancer dans l’implémentation, décidez de la structure de données que vous souhaitez employer pour stocker les coefficients dans votre classe Polynome.
• Votre classe Polynome aura deux constructeurs :
  • Le premier permet de créer un polynôme en fournissant un tableau de coefficients. Par exemple, Polynome p1{ {1.2, 3, 4, 5} }; crée le polynôme 1.2 + 3X + 4X^2 + 5X^4
  • Le second permet de créer un polynôme en fournissant une liste de paires (degré, coefficient). Par exemple, Polynome p2{ {{0,1.2}, {1,3}, {2000,4}} }; crée le polynôme 1.2 + 3X + 4X^2000
• Dans unitTests/unitTests.cpp, écrivez le test TEST(Creation, AvecCoefsNonNuls) (cf. code ci-dessous) et modifiez src/Polynome.h et src/Polynome.cpp pour que ce test soit OK. NB : Ce test suppose que vous avez défini, dans src/Polynome.h, la méthode : bool operator==(const Polynome&) const = default;

        TEST(Creation, AvecCoefsNonNuls) {
           Polynome p1{ {1.2, 3, 4, 5} };
           Polynome p2{ {{0,1.2}, {1,3}, {2,4}, {3,5}} };
           EXPECT_EQ(p1, p2);
        }

• Pour vous faciliter la lecture des éventuelles erreurs affichées par GoogleTest, définissez l’opérateur << pour votre classe polynôme et, pour vérifier que votre affichage est correct, affichez un polynôme grâce à du code écrit dans src/myMain.cpp.
• Si vous le souhaitez, ajoutez de nouveaux tests de création de polynôme. Nous vous suggérons notamment d’écrire un test TEST(Creation, AvecCoefsNuls) pour voir comment votre code résiste à des coefficients nuls.

        TEST(Creation, AvecCoefsNuls) {
            Polynome p1{ {{0,1}, {1,0}, {2,3}, {3,4}, {2000,0}} };
            Polynome p2{ {{0,1},        {2,3}, {3,4},         } };
            EXPECT_EQ(p1, p2);
        }

• Écrivez des tests vérifiant le fonctionnement de la fonction faisant la somme de 2 polynômes. Puis, implémentez votre fonction de somme (en vérifiant son fonctionnement avec vos tests).

        TEST(Somme, SommeSansRienDeParticulier) {
            Polynome p1{ {1, 0, 2, 1} };
            Polynome p2{ {1, 2, 0, 1} };
            Polynome somme_ref{ {2, 2, 2, 2} };
            EXPECT_EQ(p1 + p2, somme_ref);
            EXPECT_EQ(p2 + p1, somme_ref);
        }
        TEST(Somme, SommeOuCoefsSAnnulent) {
            Polynome p1{ {1, 0, 2,  1} };
            Polynome p2{ {1, 2, 0, -1} };
            Polynome somme_ref{ {2, 2, 2} };
            EXPECT_EQ(p1 + p2, somme_ref);
            EXPECT_EQ(p2 + p1, somme_ref);
        }
        TEST(Somme, SommeAvecPolynomeNul) {
            Polynome p{ {1, 0, 2, 1} };
            Polynome p_nul;
            EXPECT_EQ(p + p_nul, p);
            EXPECT_EQ(p_nul + p, p);
        }

• Modifiez votre code pour que le test suivant compile et fonctionne (NB : vous n’avez pas à écrire une nouvelle version de Polynome operator+(...)) :

        TEST(Somme, SommeAvecConstante) {
           Polynome p{ {0, 0, 2, 1} };
           double d{ 1.2 };
           Polynome somme_ref{ {1.2, 0, 2, 1} };
           EXPECT_EQ(p + d, somme_ref);
           EXPECT_EQ(d + p, somme_ref);
        }

• Écrivez des tests vérifiant le fonctionnement de la méthode retournant la dérivée d’un polynôme. Puis, implémentez cette méthode (en vérifiant son fonctionnement avec vos tests).
• Même exercice avec la méthode retournant le degré d’un polynôme.
• Recopiez tous les tests du corrige_unitTests.cpp dans votre propre fichier unitTests/unitTests.cpp. Vérifiez que tous les tests sont OK et améliorez votre code si ce n’est pas le cas.

3 Pour aller plus loin

Si vous avez réalisé une implémentation à base de vector (respectivement map), faites l’implémentation à base de map(respectivement vecteur). Pour ce faire :

• Renommez Polynome.cpp en PolynomeVersionVector.cpp (respectivement PolynomeVersionMap.cpp)

• Modifiez votre CMakeLists.txt pour qu’il ne contienne désormais que ces lignes :

  add_library(src myMain.cpp myMain.h
                  Polynome.h PolynomeVersionVector.cpp)
  target_include_directories(src PUBLIC ./)

• Vérifiez que votre programme compile toujours et que vos tests sont toujours corrects.

• Passons maintenant à la nouvelle implémentation :

  • Dans Polynome.h, remplacez std::vector<double> coef; par std::map<unsigned int, double> coef; (ou vice-versa).
  • Copiez PolynomeVersionVector.cpp en PolynomeVersionMap.cpp ou vice-versa.
  • Dans CMakeLists.txt, remplacez PolynomeVersionVector par PolynomeVersionVector (ou vice-versa).
  • Demandez à votre IDE de recharger votre projet pour prendre en compte ce changement.
  • Modifiez votre nouveau fichier .cpp jusqu’à sa compilation et les tests soient OK.

NB :

1. Cette manière de mettre en place une nouvelle implémentation est classique. Elle permet, par exemple, de faire des tests de performance entre différentes implémentations, en vue de retenir la meilleure.
2. Dans un même programme, il est possible de faire cohabiter plusieurs implémentations à l’aide du patron de conception Fabrique.

Corrigé (à exploiter selon la procédure cmake de ce document).