Construire un jeu de tests d'au moins huit cas pour complement a 2 du…

Les trois familles, appliquées à complement_a_2(x, n).

• cas ordinaires : $42$ et $-42$ sur $8$ bits ;
• cas limites : $0$ ; $1$ et $-1$, qui se ressemblent le moins possible ; $127$ et $-128$, les deux bornes exactes du domaine sur $8$ bits ; $-2$, dont l'écriture 11111110 révèle qu'on ne complémente pas naïvement ;
• cas interdits : $128$ et $-129$ sur $8$ bits, hors du domaine, qui doivent déclencher l'assertion.

cas_c2 = [
    ((0, 8),    "00000000"),
    ((1, 8),    "00000001"),
    ((-1, 8),   "11111111"),
    ((127, 8),  "01111111"),
    ((-128, 8), "10000000"),
    ((-2, 8),   "11111110"),
    ((42, 8),   "00101010"),
    ((-42, 8),  "11010110"),
    ((0, 4),    "0000"),
    ((-8, 4),   "1000"),
    ((7, 4),    "0111"),
]
tester(complement_a_2, cas_c2)      # 0 echec(s) sur 11 cas

Onze cas, aucun échec.

Les cas interdits se testent autrement : on n'attend pas une valeur, on attend une erreur.

refuses = 0
for x, n in [(128, 8), (-129, 8), (8, 4), (-9, 4)]:
    try:
        complement_a_2(x, n)
    except AssertionError:
        refuses = refuses + 1
print(refuses)      # 4

Les quatre appels sont bien refusés. Un test qui vérifie qu'un programme refuse vaut autant qu'un test qui vérifie qu'il accepte.

Le test qui vaut tous les autres. Onze cas restent onze cas. L'aller-retour, lui, couvre tout le domaine :

for n in (4, 8, 12):
    for x in range(-2**(n - 1), 2**(n - 1)):
        assert depuis_complement_a_2(complement_a_2(x, n)) == x

Soit $16+256+4096=4368$ valeurs, toutes correctes.

Et pourtant : cet aller-retour ne prouverait rien si les deux fonctions étaient fausses de manière inverse. Les onze cas écrits à la main, dont les valeurs attendues viennent du cours et non du code, gardent donc leur utilité. Les deux formes de test se complètent.