Spécifications, Tests et écriture de code
Spécifications, Tests et écriture de code
Programming, Software Engineering · course
Fiche de révisionFiche de cours
Rédigée à partir de ce document, puis vérifiée avant publication.
Ce document couvre les notions fondamentales liées aux spécifications fonctionnelles, à la conception, aux tests unitaires et à l’écriture de code en génie logiciel. Il s’adresse principalement aux étudiants en informatique et aux développeurs souhaitant approfondir leur compréhension du processus de développement logiciel, notamment à travers la programmation pilotée par les tests (TDD) et un exemple concret d’implémentation en Java.
La conception d’un programme suit plusieurs étapes clés :
Les principes de conception tels que le masquage de l’information, l’utilisation des interfaces Java et des classes abstraites jouent un rôle important dans la qualité et la maintenabilité du code.
Les spécifications fonctionnelles décrivent précisément le comportement attendu d’un logiciel. Elles doivent :
Par exemple, la méthode distance(Node noeud1, Node noeud2) d’une classe Graph doit retourner la distance entre deux nœuds ou -1 si ces nœuds ne sont pas reliés. Cette règle doit être clairement documentée, souvent via la javadoc.
Le cahier des charges est un document essentiel qui fixe les besoins fonctionnels avant le développement, afin d’éviter les dérives.
Les tests unitaires permettent de vérifier que chaque morceau de code fonctionne comme prévu. Ils améliorent la qualité générale du logiciel et clarifient la documentation.
La méthode TDD recommande d’écrire d’abord les tests unitaires, puis le code qui les fait passer, selon le cycle suivant :
Cette démarche permet de réfléchir aux différents cas d’usage avant même d’avoir implémenté la fonctionnalité.
Il est important de couvrir :
Bien que cela nécessite d’écrire plus de code, les tests unitaires facilitent la maintenance et la collaboration en équipe.
Considérons la méthode suivante :
/**
* Met la valeur 0 sur les len premières valeurs du tableau.
*
* @param tab, le tableau de départ d’une longueur d’au moins len
* @param len, le nombre de cases à mettre à 0
*/
public void resetPartiel(int[] tab, int len)
Les tests à envisager sont :
len invalide (négative, nulle, supérieure à la taille du tableau).Le Black Box Testing consiste à tester les fonctionnalités sans connaissance de l’implémentation, en se concentrant sur les cas difficiles et les comportements attendus.
Le White Box Testing consiste à tester en connaissant le code source, en vérifiant les structures de données, les itérations et la coopération entre objets.
JUnit est un environnement de test unitaire très utilisé en industrie, intégré dans la plupart des IDE comme Eclipse ou IntelliJ. Il permet d’organiser les tests dans un répertoire dédié et propose des annotations pour gérer le cycle de vie des tests :
@Test : indique une méthode de test.@BeforeEach : méthode exécutée avant chaque test, pour initialiser l’objet testé.@AfterEach : méthode exécutée après chaque test, pour nettoyer (fermer fichiers, connexions...).@BeforeAll : méthode exécutée une fois avant tous les tests.JUnit fournit aussi des assertions pour vérifier les résultats :
assertEquals(expected, actual)assertTrue(condition), assertFalse(condition)assertNotNull(object), assertNull(object)assertSame(expected, actual), assertNotSame(expected, actual)Le Prime Factors Kata est un exercice de programmation visant à écrire une méthode statique generate dans une classe PrimeFactors qui, donnée un entier n, retourne la liste des facteurs premiers de n dans l’ordre croissant.
package primeFactors;
import java.util.*;
public class PrimeFactors {
public static List<Integer> generate(int n) {
return new ArrayList<Integer>();
}
}
package primeFactors;
import junit.framework.TestCase;
import java.util.*;
public class PrimeFactorsTest extends TestCase {
private List<Integer> list(int... ints) {
List<Integer> list = new ArrayList<Integer>();
for (int i : ints)
list.add(i);
return list;
}
public void testOne() throws Exception {
assertEquals(list(), PrimeFactors.generate(1));
}
public void testTwo() throws Exception {
assertEquals(list(2), PrimeFactors.generate(2));
}
public void testThree() throws Exception {
assertEquals(list(3), PrimeFactors.generate(3));
}
public void testFour() throws Exception {
assertEquals(list(2, 2), PrimeFactors.generate(4));
}
public void testSix() throws Exception {
assertEquals(list(2, 3), PrimeFactors.generate(6));
}
public void testEight() throws Exception {
assertEquals(list(2, 2, 2), PrimeFactors.generate(8));
}
public void testNine() throws Exception {
assertEquals(list(3, 3), PrimeFactors.generate(9));
}
}
generateLa méthode est améliorée au fur et à mesure des tests :
public static List<Integer> generate(int n) {
List<Integer> primes = new ArrayList<Integer>();
for (int candidate = 2; n > 1; candidate++) {
for (; n % candidate == 0; n /= candidate)
primes.add(candidate);
}
return primes;
}
Cette version utilise deux boucles imbriquées :
n autant de fois que possible par ce candidat et ajoute ce facteur à la liste.Pour n = 12 :