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 Polynôme.

• Votre classe Polynôme aura deux constructeurs :

  • Le premier permet de créer un polynôme en fournissant un vector de coefficients. Par exemple, Polynôme 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 map de paires (degré, coefficient). Par exemple, Polynôme 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/Polynôme.h, la méthode : bool operator==(const Polynôme&) const = default;
  • Pour la ligne Polynôme p2{ {{0,1.2}, {1,3}, {2,4}, {3,5}} }; du test ci-dessous, selon vous, vaut-il mieux considérer que p2 est défini à l’aide d’un vector<pair<int, double>, d’une map<int, double> ou bien encore d’une unordered_map<int, double> ? N’hésitez pas à en discuter avec l’intervenant·e si la réponse n’est pas claire pour vous.

        TEST(Creation, AvecCoefsNonNuls) {
           Polynôme p1{ {1.2, 3, 4, 5} };
           Polynôme 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) {
            Polynôme p1{ {{0,1}, {1,0}, {2,3}, {3,4}, {2000,0}} };
            Polynôme 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) {
            Polynôme p1{ {1, 0, 2, 1} };
            Polynôme p2{ {1, 2, 0, 1} };
            Polynôme somme_ref{ {2, 2, 2, 2} };
            EXPECT_EQ(p1 + p2, somme_ref);
            EXPECT_EQ(p2 + p1, somme_ref);
        }
        TEST(Somme, SommeOuCoefsSAnnulent) {
            Polynôme p1{ {1, 0, 2,  1} };
            Polynôme p2{ {1, 2, 0, -1} };
            Polynôme somme_ref{ {2, 2, 2} };
            EXPECT_EQ(p1 + p2, somme_ref);
            EXPECT_EQ(p2 + p1, somme_ref);
        }
        TEST(Somme, SommeAvecPolynômeNul) {
            Polynôme p{ {1, 0, 2, 1} };
            Polynôme 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 Polynôme operator+(...)) :

        TEST(Somme, SommeAvecConstante) {
           Polynôme p{ {0, 0, 2, 1} };
           double d{ 1.2 };
           Polynôme 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 src/core/CMakeLists.txt pour qu’il ne contienne désormais que les lignes suivantes :

add_library(lib_core
  myMain.cpp myMain.h
  Polynome.h PolynomeVersionVector.cpp
)

target_include_directories(lib_core PUBLIC ./)

• Vérifiez que votre programme compile toujours et que vos tests sont toujours corrects.
• Passez 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 src/core/CMakeLists.txt, remplacez PolynomeVersionVector par PolynomeVersionMap (ou vice-versa).
  • Demandez à votre IDE de recharger votre projet pour prendre en compte ce changement.
  • Modifiez votre nouveau fichier .cpp jusqu’à ce que 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 (comme nous l’avions expérimenté avec le TP Six qui prend).
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).