Optimisation - Partie II : Tests Unitaires

A- Introduction

Après avoir réalisé une nouvelle fonction dans un programme, il convient, en toute logique, de la tester. Ce test est appelé test unitaire.

Ce test, essentiel afin de s'assurer de la bonne fiabilité du programme, se base sur le contrôle de trois éléments de base :
- le déroulement sans erreur de la fonction
- les fonctionnalités
- la bonne vitesse d'exécution

Pour cela, il est courant d'utiliser des logiciels de 'couverture de programme' ou 'code coverage', qui permettront de suivre pas à pas le déroulement du programme, en fournissant des informations complémentaires des plus utiles, comme le nombre de fois où chaque ligne de code est exécutée, ainsi que leurs temps d'exécution.

B- Déroulement sans erreur de la fonction

La première chose attendue d'une fonction est quelle ne fasse pas se 'planter' le programme. Cette partie du test se fait logiquement en parallèle les autres. L'utilitaire de couverture de programme sera utile car il permettra de s'assurer que toutes les lignes de codes ont bien été exécutées, et donc testées, au moins une fois.

La principale difficulté restera de réaliser un jeu d'essai exhaustif qui permettra de couvrir toutes les combinaisons possibles d'exécution. On voit là tout l'intérêt qu'il y a à écrire des procédures aux traitements très ciblés.

C- Fonctionnalités

Il s'agit là de tester la fonction première des traitements, soit de vérifier le résultat obtenu en fonction des éléments passés en entrée.

Idéalement, pour réaliser les jeux d'essais, on parcourra la procédure en notant chaque variable ou objet utilisé, puis, sur 'papier', on les fera varier en déterminant à chaque fois le résultat attendu. Dans une seconde phase, on testera la fonction avec ces valeurs en entrée, et on vérifiera le résultat obtenu par rapport à celui attendu.

Pour cette partie du test, il convient aussi de surveiller toutes les valeurs des variables utilisées dans le traitement afin de suivre leur évolution : en effet, si la fonction remplit bien sa fonction initiale, il faut aussi s'assurer qu'elle ne va pas entraîner des erreurs sur les traitements suivants car elle aura modifié des objets ou des variables de façon inappropriées. Il est a noter que les tests d'intégration viendront compléter ces tests préliminaires.


D- Bonne vitesse d'exécution

Le dernier point à traiter lors du test d'intégration est la vitesse d'exécution afin de repérer au plus tôt les 'freins à main'. L'outil de couverture de programme sera ici aussi très utile. Les points à surveiller sont, la durée d'exécution de chaque ligne, mais aussi la répétition de l'exécution de ces dernières. En effet, répéter cent fois la même ligne, aussi rapide soit-elle, finira pas avoir un impact sur la durée d'exécution du traitement.

E- Conclusion

Les tests unitaires sont le premier rempart mis en place contre les plantages et autres disfonctionnements. Ils sont malheureusement souvent coûteux en temps et, par conséquents, restreints aux fonctions critiques, voir parfois simplement abandonnés en premier lieu, pour être effectués de façon très ciblée suite à des tests d'intégration peu concluants.