Teste sur le parcours C++

Apprends à tester tes exercices C++ sur Exercism.

Chaque exercice fournit les tests unitaires ainsi qu'une recette de compilation CMake. C'est à toi d'écrire l'implémentation. Chaque fichier de test est destiné à être lié à ton implémentation afin de produire un exécutable en console qui lance les tests. Lancer l'exécutable de test affiche un message pour chaque test qui échoue et renvoie un code de sortie non nul lorsque des tests échouent.

Remarque : ton code est testé par la suite de tests à chaque fois que tu compiles ton projet. Si ton code ne passe pas un ou plusieurs tests mais qu'il s'agit de code C++ valide, il sera quand même compilé.

La démarche, pour chaque exercice, est la suivante :

  • Créer la compilation initiale avec CMake
  • Pour chaque test unitaire :
    • Résous les erreurs de compilation pour que le test échoue.
    • Implémente juste ce qu'il faut pour que le test passe.
    • Réécris ton implémentation pour améliorer la lisibilité, réduire les duplications, etc.
    • Décommente le test suivant

Crée la compilation initiale avec CMake

Chaque exercice apporte un fichier CMakeLists.txt en même temps que les tests unitaires. Il contient la recette CMake prête à l'emploi qui gère la compilation à ta place. Tu ne devrais pas avoir besoin de modifier ce fichier. La recette fournie part du principe que ton implémentation se présente sous la forme d'un fichier d'en-tête et d'un fichier source nommés d'après l'exercice.

Par exemple, l'exercice bob attend une implémentation dans bob.h et bob.cpp. Pour les exercices dont le nom contient des tirets, on suppose que les fichiers source utilisent des tirets bas, donc word-count attend word_count.h et word_count.cpp. Tu peux décider que ton implémentation est suffisamment simple pour tenir entièrement dans l'en-tête, auquel cas tu peux omettre le fichier cpp.

Crée les fichiers de ton implémentation initiale avant de lancer CMake. Si tu n'as pas les fichiers bob.h et bob.cpp au moment de lancer CMake pour l'exercice bob, CMake générera une erreur indiquant que des fichiers sont introuvables. Ces fichiers peuvent être vides, mais ils doivent exister.

Avec cette recette, CMake peut générer un projet adapté à ton environnement en lançant cmake -G avec un générateur approprié et l'emplacement du répertoire de l'exercice. CMake générera un script de compilation adapté à ton système d'exploitation. Pour garder ces fichiers générés séparés du code source de ton exercice, il est courant de créer un répertoire nommé build pour y placer ces fichiers de compilation générés, ainsi que le code compilé. Cela permet de garder le dossier de ton exercice propre et bien rangé.

Une fois que CMake a créé l'environnement de compilation, tu peux compiler ton code avec la commande adaptée à ton environnement :

  • Linux avec make : make
  • Windows avec Visual Studio : sélectionne Build / Build Solution dans le menu.
  • MacOS avec Xcode : sélectionne Build dans la barre d'outils.
  • MacOS avec « Unix Makefile » : make si tu utilises l'application Exercism CLI

Tu trouveras ci-dessous des exemples d'exécution de CMake pour différents environnements.

Linux avec Make

Le nom du générateur pour CMake est Unix Makefiles. En supposant que l'exercice en cours soit bob et que l'on se trouve dans le dossier de l'exercice :

$ touch bob.{h,cpp}
$ mkdir build
$ cd build
$ cmake -G "Unix Makefiles" ..
$ make

Cet exemple montre comment créer des fichiers vides pour l'implémentation avant de lancer CMake.

Tape simplement make dans le répertoire build pour compiler les tests. Cela devrait générer des erreurs de compilation. Une fois les erreurs corrigées, make compilera et lancera les tests.

Windows avec Visual Studio

Visual Studio prend nativement en charge les projets CMake, tu ne devrais donc pas avoir besoin d'installer CMake séparément ni de le lancer en dehors de Visual Studio. Suis ce guide pour configurer le projet CMake dans Visual Studio.

MacOS avec Xcode

Le nom du générateur pour CMake est Xcode. En supposant que l'exercice en cours soit bob et que l'on se trouve dans le dossier de l'exercice :

$ touch bob.{h,cpp}
$ mkdir build
$ cd build
$ cmake -G Xcode ..

Cet exemple génère les fichiers XCode pour que tu puisses ouvrir le projet dans XCode. Une fois le projet ouvert dans XCode, tu devras peut-être ajouter une autre cible. Pour créer une nouvelle cible, va dans File -> New -> Target depuis le menu, OS X \ Application \ Command Line Tool -> Next, choisis C++ comme langage et indique un nom de cible. Lance le code à l'aide de la cible.

Si ton terminal renvoie une erreur Xcode x.x not supported, il est très probable que Xcode ne soit pas installé sur ta machine ou que ta version soit obsolète. Télécharge et installe Xcode depuis l'App Store ou via ce lien. Les erreurs du type The CXX compiler identification is unknown se résolvent probablement en suivant les instructions d'installation de GCC ou en ajoutant une autre cible dans Xcode comme expliqué au paragraphe ci-dessus.

MacOS avec Make lorsque tu utilises l'Exercism CLI

Cet exemple s'adresse particulièrement à celles et ceux qui veulent utiliser l'application Exercism CLI pour configurer, tester et soumettre leurs exercices C++.

Le nom du générateur pour CMake est Unix Makefiles. En supposant que l'exercice en cours soit bob et que l'on se trouve dans le dossier de l'exercice :

$ touch bob.{h,cpp}
$ cmake -G "Unix Makefiles" .
$ exercism test

Dans cet exemple, on crée bien des fichiers vides pour l'implémentation avant de lancer CMake, mais on ne crée pas de répertoire build vide. C'est parce que l'Exercism CLI utilise le fichier .exercism/metadata.json du répertoire racine pour analyser les cas de test.

Tape simplement exercism test dans le répertoire racine pour compiler les tests. Cela devrait générer des erreurs de compilation. Une fois les erreurs corrigées, relancer exercism test compilera et exécutera les tests à l'aide de l'Exercism CLI.