Déboguer et fiabiliser

Point de départ

// ── 1. Un débogueur miniature ─────────────────────────────────────────────
// Chaque « instruction » est une fonction qui modifie l'état. Le débogueur
// exécute pas à pas, affiche l'état, et surveille une variable.
function executer(programme, surveillee) {
  const etat = {};
  let precedente;
  programme.forEach((instruction, ligne) => {
    instruction.faire(etat);
    const v = etat[surveillee];
    const change = v !== precedente;
    console.log("   ligne " + String(ligne + 1).padStart(2) + "  " +
      instruction.texte.padEnd(30) + JSON.stringify(etat) +
      (change && precedente !== undefined ? "   << " + surveillee + " a changé" : ""));
    precedente = v;
  });
  return etat;
}

// Un calcul de moyenne, avec une faute quelque part.
const PROGRAMME = [
  { texte: "somme = 0",              faire: (e) => { e.somme = 0; } },
  { texte: "n = 0",                  faire: (e) => { e.n = 0; } },
  { texte: "somme += 12",            faire: (e) => { e.somme += 12; e.n++; } },
  { texte: "somme += 15",            faire: (e) => { e.somme += 15; e.n++; } },
  { texte: "somme += 9",             faire: (e) => { e.somme += 9; } },   // ← n oublié
  { texte: "moyenne = somme / n",    faire: (e) => { e.moyenne = e.somme / e.n; } },
];

// ── 2. Lire un rapport de type valgrind ───────────────────────────────────
const RAPPORT = [
  "Invalid write of size 4",
  "   at 0x109189: remplir (tri.c:23)",
  " Address 0x4a47054 is 0 bytes after a block of size 40 alloc'd",
  "   at 0x484A899: malloc",
  "   by 0x109165: main (tri.c:11)",
  "",
  "LEAK SUMMARY:",
  "   definitely lost: 40 bytes in 1 blocks",
  "   still reachable: 128 bytes in 2 blocks",
];

// ── 3. Un jeu de tests ────────────────────────────────────────────────────
let echecs = 0;
function verifier(condition, description) {
  if (!condition) { console.log("   ÉCHEC : " + description); echecs++; }
}

// La fonction à tester : rend l'indice du maximum d'un tableau.
function indiceDuMax(T, n) {
  let meilleur = 0;
  for (let i = 1; i < n; i++) if (T[i] > T[meilleur]) meilleur = i;
  return meilleur;
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Lancez executer() en surveillant « n » : à quelle ligne l'état
//    diverge-t-il de ce que vous attendiez ? C'est le watch de gdb.
// 2. Lisez RAPPORT : quelle est la nature de la faute, où se produit-elle,
//    et où le bloc concerné a-t-il été alloué ? Quelle ligne corriger ?
// 3. Écrivez des tests pour indiceDuMax : cherchez les BORNES (tableau d'un
//    élément, valeurs égales, tableau vide) plutôt que des cas ordinaires.

console.log("— exécution pas à pas, surveillance de « n » —");
executer(PROGRAMME, "n");

Solution

function executer(programme, surveillee) {
  const etat = {};
  let precedente;
  programme.forEach((instruction, ligne) => {
    instruction.faire(etat);
    const v = etat[surveillee];
    const change = v !== precedente;
    console.log("   ligne " + String(ligne + 1).padStart(2) + "  " +
      instruction.texte.padEnd(30) + JSON.stringify(etat) +
      (change && precedente !== undefined ? "   << " + surveillee + " a changé" : ""));
    precedente = v;
  });
  return etat;
}

const PROGRAMME = [
  { texte: "somme = 0",           faire: (e) => { e.somme = 0; } },
  { texte: "n = 0",               faire: (e) => { e.n = 0; } },
  { texte: "somme += 12",         faire: (e) => { e.somme += 12; e.n++; } },
  { texte: "somme += 15",         faire: (e) => { e.somme += 15; e.n++; } },
  { texte: "somme += 9",          faire: (e) => { e.somme += 9; } },
  { texte: "moyenne = somme / n", faire: (e) => { e.moyenne = e.somme / e.n; } },
];

console.log("— 1. exécution pas à pas, surveillance de « n » —");
const fin = executer(PROGRAMME, "n");
console.log("   moyenne obtenue : " + fin.moyenne + "   attendue : " + (36 / 3).toFixed(2));
console.log("   Le watch le dit : n change aux lignes 3 et 4, PAS à la ligne 5.");
console.log("   La faute n'est pas dans la division mais trois lignes plus haut —");
console.log("   c'est exactement l'écart entre le symptôme et sa cause.");

console.log("");
console.log("— 2. lecture du rapport —");
const RAPPORT = [
  "Invalid write of size 4",
  "   at 0x109189: remplir (tri.c:23)",
  " Address 0x4a47054 is 0 bytes after a block of size 40 alloc'd",
  "   at 0x484A899: malloc",
  "   by 0x109165: main (tri.c:11)",
  "",
  "LEAK SUMMARY:",
  "   definitely lost: 40 bytes in 1 blocks",
  "   still reachable: 128 bytes in 2 blocks",
];
for (const l of RAPPORT) console.log("   | " + l);
console.log("");
console.log("   NATURE      : Invalid write — une ÉCRITURE hors d'un bloc alloué.");
console.log("   OÙ          : tri.c ligne 23, dans remplir().");
console.log("   QUEL BLOC   : celui alloué à tri.c ligne 11, de 40 octets — soit");
console.log("                 10 int. « 0 bytes after » signifie qu'on écrit à");
console.log("                 l'indice 10 d'un tableau qui s'arrête à 9 : un");
console.log("                 débordement d'exactement UNE case, la faute type.");
console.log("   FUITE       : definitely lost 40 octets — plus aucun pointeur ne");
console.log("                 désigne le bloc. Les 128 octets « still reachable »");
console.log("                 sont encore atteignables à la fin : souvent bénin.");
console.log("   À CORRIGER  : la borne de la boucle en tri.c:23, pas l'allocation.");

console.log("");
console.log("— 3. jeu de tests —");
let echecs = 0;
function verifier(condition, description) {
  if (!condition) { console.log("   ÉCHEC : " + description); echecs++; }
  else console.log("   ok    : " + description);
}

function indiceDuMax(T, n) {
  let meilleur = 0;
  for (let i = 1; i < n; i++) if (T[i] > T[meilleur]) meilleur = i;
  return meilleur;
}

// Les cas ordinaires passent toujours : ce ne sont pas eux qui informent.
verifier(indiceDuMax([3, 17, 8], 3) === 1, "cas ordinaire, max au milieu");
verifier(indiceDuMax([42, 3, 8], 3) === 0, "max en tête");
verifier(indiceDuMax([3, 8, 42], 3) === 2, "max en queue");

// Les BORNES, elles, révèlent.
verifier(indiceDuMax([7], 1) === 0, "un seul élément");
verifier(indiceDuMax([5, 5, 5], 3) === 0, "valeurs toutes égales : le PREMIER indice");
verifier(indiceDuMax([-3, -1, -7], 3) === 1, "que des négatifs (un 0 initial casserait tout)");
// Le cas dégénéré : que doit rendre la fonction sur un tableau vide ? La
// question n'a pas de réponse — c'est le signe qu'il fallait une PRÉCONDITION,
// donc une assertion, et non une valeur de retour inventée.
console.log("   n = 0 : indiceDuMax rend " + indiceDuMax([], 0) +
            ", un indice qui n'existe pas -> assert(n > 0) s'impose");

console.log("");
console.log("   " + echecs + " échec(s). Le bogue corrigé devient un test de plus,");
console.log("   pour qu'il ne revienne jamais.");

Avant de commencer

• Le fil rouge journal, complet
• gdb, valgrind, les détecteurs, et de quoi écrire des tests

Énoncé

1. Un programme sabotté — Échangez votre fil rouge avec un binôme après y avoir introduit trois bogues : un plantage, un résultat faux, une fuite. Chacun doit trouver les trois de l'autre, en chronométrant.
2. Reproduire d'abord — Pour chaque bogue trouvé, écrivez la plus petite entrée qui le déclenche. Réduisez-la jusqu'à ce qu'enlever une ligne fasse disparaître le problème. Indice : Un bogue qu'on ne sait pas reproduire ne peut pas être corrigé, seulement masqué.
3. Le débogueur — Placez un point d'arrêt conditionnel qui ne se déclenche qu'au tour de boucle fautif. Inspectez les variables, remontez la pile, et identifiez l'appelant responsable.
4. Le point d'observation — Utilisez un point d'observation sur une variable qui change sans raison apparente. Notez la ligne exacte qui l'a modifiée.
5. Les assertions — Ajoutez des assertions aux entrées et sorties de vos fonctions, exprimant les contrats écrits au TP 4. Vérifiez qu'une assertion se déclenche sur une entrée invalide, puis compilez avec NDEBUG.
6. Les tests — Écrivez une dizaine de tests couvrant les cas limites : fichier vide, une seule ligne, ligne tronquée, très longue ligne, caractères accentués. Faites-les tourner par make test.
7. Le filet complet — Faites passer tout le fil rouge sous les trois outils, avec les avertissements en erreurs. Corrigez jusqu'à ce que tout soit propre.
8. Le bogue par recherche — Introduisez un bogue plusieurs commits en arrière dans votre dépôt, puis retrouvez le commit fautif par recherche dichotomique automatisée.

C'est réussi quand

• ✓ Vous trouvez les trois bogues de votre binôme, et vous savez lequel a été le plus long
• ✓ Votre entrée réduite tient en trois lignes
• ✓ make test passe, et échoue si vous cassez une seule fonction
• ✓ Compilation propre sous -Wall -Wextra -Werror et les trois outils

Correction

1. REPRODUIRE   — sinon on ne peut rien vérifier
2. RÉDUIRE      — la plus petite entrée qui échoue
3. LOCALISER    — bissection dans le code, ou l'outil qui le dit
4. COMPRENDRE   — pourquoi, pas seulement où
5. CORRIGER
6. TESTER       — un test qui échouait avant, réussit après

l'étape 4 est celle qu'on saute, et c'est celle qui évite
de « corriger » un symptôme en déplaçant la cause

break analyse.c:42 if i == 9999   # arrêt conditionnel
run acces.log
bt                                # pile d'appels
frame 1                           # remonter à l'appelant
print *l                          # afficher une structure entière
print t[i]@10                     # dix éléments à partir de i
watch total                       # ARRÊT dès que total change
finish                            # exécuter jusqu'au retour

#include <assert.h>

int somme(const int *t, size_t n) {
  assert(t != NULL);          /* précondition */
  long s = 0;
  for (size_t i = 0; i < n; i++) s += t[i];
  assert(s >= 0 || t_contient_des_negatifs);  /* postcondition */
  return s;
}

gcc -DNDEBUG : toutes les assertions DISPARAISSENT du binaire

#!/bin/sh
set -e
verifier() {  # attendu, entrée, description
  obtenu=$(./journal "$2" 2>&1) || true
  [ "$obtenu" = "$1" ] || { echo "ÉCHEC : $3"; exit 1; }
}

: > vide.log            ; verifier "0 lignes" vide.log "fichier vide"
printf 'a\n'   > un.log ; verifier "1 lignes" un.log  "une ligne"
printf 'tronq' > tr.log ; verifier "1 lignes" tr.log   "sans saut final"
echo "tous les tests passent"

CFLAGS = -Wall -Wextra -Werror -std=c17 -g

verifier: journal
valgrind --leak-check=full --error-exitcode=1 ./journal essai.log
$(CC) $(CFLAGS) -fsanitize=address,undefined *.c -o journal-san
./journal-san essai.log
./test.sh

git bisect start
git bisect bad                 # la version actuelle échoue
git bisect good v1.0           # cette version-là fonctionnait
git bisect run ./test.sh       # git teste automatiquement

→ 7 essais pour 100 commits (log2), commit fautif désigné
avec son auteur, sa date et son message