Guillaume Hormiere Un gros pense-bete

Utiliser Gcov

Lors du bureau d’étude de mon master 1, portant sur Libmediawiki, un de nos objectifs principaux était de produire un bibliothèque de qualité. Qualité indispensable pour garantir aux développeurs que notre nouvel outil est fiable et robuste.

Pour atteindre cet objectif, on s'est armé d'outils classiques, comme les bons vieux tests unitaires, mais aussi de moyens plus intéressants, nous permettant de mesurer la pertinence de nos tests, ainsi que de suivre l’évolution de ces métriques dans le temps.

Aujourd'hui, je vais traiter de la manière d'acquérir ces mesures grâces à GCov, et je publierai dans un prochain article l'outil de suivi.

GCov est un outil permettant d’acquérir des métriques sur couverture de  code. Couplé à Gcc et CMake, il permet de mettre en place des mesures de façon simple et efficace. Dans le cadre du projet, son utilisation a permis d'avoir un retour sur la pertinence de nos tests unitaires. Ainsi quand on jouait nos tests, on avait deux retours : le résultat des tests et le pourcentage de codes couverts par ceux-ci.

Par la suite on vas utiliser le code source suivant, tiré de l'exemple de la documentation de Gcc:

#include <stdio.h>
 int main (void){
 int i;
 for (i = 1; i < 10; i++)
 {
 if (i % 3 == 0)
 printf ("%d is divisible by 3\n", i);
 if (i % 11 == 0)
 printf ("%d is divisible by 11\n", i);
 }
 return 0;
 }

GCov est un outil très simple à utiliser. Il suffit de passer les options "-fprofile-arcs -ftest-coverage" à Gcc lors de la compilation. Ces "flags" permettent au compilateur d'ajouter des instructions qui comptent le nombre de fois où la ligne de code est exécutée.

gcc -fprofile-arcs -ftest-coverage main.c

Lors de l’exécution d'un des tests unitaire des fichiers .gcno et .gcda sont générés. Ces fichiers contiennent les informations sur la couverture de code.

Étape suivante, on utilise la commande gcov pour interpréter les fichiers générés. Cette commande s'utilise de la manière suivante :

gcov main.c

Une fois exécuté, le pourcentage de couverture de code s'affiche et un fichier .gcov est généré.

$ gcov main.c
 File 'main.c'
 Lines executed:85.71% of 7
 main.c:creating 'main.c.gcov'

Dans ce fichier, on trouve un copie des sources, le numéro des lignes et le nombre de passages sur la ligne ( les lignes n’étant pas couverte sont marquées ##### ).

  -:              0:Source:main.c
 -:               0:Graph:main.gcno
 -:               0:Data:main.gcda
 -:               0:Runs:1
 -:               0:Programs:1
 -:               1:#include <stdio.h>
 -:               2:
 -:               3:int
 1:               4:main (void)
 -:               5:{
 -:               6:  int i;
 -:               7:
10:               8:  for (i = 1; i < 10; i++)
 -:               9:    {
 9:              10:      if (i % 3 == 0)
 3:              11:        printf ("%d is divisible by 3\n", i);
 9:              12:      if (i % 11 == 0)
 #####:          13:        printf ("%d is divisible by 11\n", i);
 -:              14:    }
 -:              15:
 1:              16:  return 0;
 -:              17:}

C'est dur de faire de la couverture de code...

Il existe des manières de faire plus poussées, mais je ne les traiterai pas, car elles ne sont pas nécessaires pour le prochain article. Aussi, si elles vous intéressent, je vous conseille de faire un tour sur le site de Gcc.

Tout cela ajouté à une pincé de T.D.D., afin d'avoir un maximum de tests représentatifs, ainsi qu'un soupçon d'automatisation, grâce notamment a CTest, et vous aurez alors un vrai début de  suivi pour la qualité de votre code.

Prochain article : CDash.