Les réponses fournies sont des réponses d'élève à prof plus que de
professionnel à professionnel.

Chaque ligne des fichiers de sortie de tests doivent *impérativement* être
conforme au format défini: elles doivent toutes contenir le résultat attendu
et le résultat obtenu.

Les rapports d'anomalie doivent reprendre explicitement *chacune* des lignes des fichiers
de sortie de tests qui ont le statut 'KO'; et éventuellemnt d'autres proches (avec le statut
'OK') si cela peut éclairer l'explication (par exemple: une anomalie qui apparaît
lorsque l'on échange l'ordre de 2 valeurs -- cf infra).

Les commentaires sur les anomalies sont souvent peu précis:
 - 2 capteurs valides: lesquels ? utiliser les noms donnés
   ce flou amalgame des anomalies qui ne sont pas de même nature
 - citer des éléments de la spécification plutôt que d'en donner
   une reformulation qui n'est pas à l'abri d'une mésinterprétation.

La conception des jeux de tests n'est pas toujours raisonnée
  - pas de prise en compte systèmatique des limites: n-1, n, n+1
  - trop de recyclage de valeurs (ie. une même valeur dans des tests
    différents); 
  - tester l'ordre des paramètres, auquel cas le recyclage de valeur
    se justifie

Pour une bonne conception des jeux de tests: analyser la spécification
en termes d'exigence de relation entre valeurs d'entrée et valeurs de sortie.

Analyse de la spécification du voteur: l'analyse doit se référer aux éléments de spécification,
voire, ici, à l'interface du module qui était fournie.

Déterminer les paramètres

Paramètres d'entrées du modules:
 - 3 valeurs de mesures: m1, m2 et m3
 - 3 indicateurs de validité des mesures: v1, v2 et v3
 sources = spéc: «les valeurs reçues de 3 capteurs»
 	   	 «une information de validité donnant l’état du capteur.»
         = .h: «3 valeurs physiques m1, m2, m3 en tenant compte de leur 
	        validité respective: v1,v2,v3.»
Remarque: les mesures ne sont pas nécessairement des valeurs entières
(cf. .h: «vote(double,int,double,int,double,int)») mais on négligera
ce point.

Paramètre de sortie:
 - une valeur réelle
 source = spéc: «la moyenne»
 	  .h: «double vote(...)»
 	  .h: «psoitive (sic) si la valeur consolidée est jugée 
 	       valide et négative sinon»

Un vecteur de test a la forme 'm1,v1,m2,v2,m3,v3:r'

Autres paramètres: les constantes
 - limites du domaine des mesures
   - limite basse: 0 
   - limite haute: 1023
 source = spéc: «valeur physique lue sur 10 bits ([0 .. 1023])»
 - valeurs des indicateurs de validité: 0 ou 1
 source = spéc: «la valeur lue est valide ou non.»
 	  .h: «La valeur 1 de v1, v2 et v3 indique une mesure valide
 	       et la valeur 0, une mesure invalide.»
 - limite de cohérence de 2 mesures 
 source = spéc: «Deux capteurs sont cohérents si leur écart est inférieur 
 	  	 à 5, strictement.»
 - limite de fiabilité d'un seul capteur
   - limite basse: 70 (inclus)
   - limite haute: 950 (inclus)
   source = spéc: «le capteur est dans la gamme [70..950]»


Déterminer les points singuliers des domaines
on ne s'intéresse qu'au valeurs nominale 
 - les mesures sont dans l'intervalle [0...1023]
 - les validités sont dans l'ensemble {0,1}

Domaine des validités de mesure:
 - v1=v2=v3=1
 - v1=v2=1 et v3=0
 - v1=v3=1 et v2=0
 - v2=v3=1 et v1=0
 - v1=1 et v2=v3=0
 - v2=1 et v1=v3=0
 - v3=1 et v1=v2=0
 - v1=v2=v3=0
 
Domaine des mesures: 
 - les couples (mi,mj) tels que |mi-mj| < 5
 - les couples (mi,mj) tels que |mi-mj| >= 5 
 - les mesures m telles que 70 <= m <= 950
 - les mesures m telles que 0 <= m < 70
 - les mesures m telles que 950 < m <= 1023

Définir la combinatoire des domaines (on peut utiliser un générateur pseudo aléatoire)
La combinatoire est ici guidée par le partitionnement du domaine de validité
Donner l'oracle de la valeur attendue

 - v1=v2=v3=1
   choisir 3 valeurs k1, k2, k3 dans [0..1023], permuter
   k1,1,k2,1,k3,1: (k1+k2+k3)/3
   k1,1,k3,1,k2,1: (k1+k2+k3)/3
   k2,1,k1,1,k3,1: (k1+k2+k3)/3
   k2,1,k3,1,k1,1: (k1+k2+k3)/3
   k3,1,k1,1,k2,1: (k1+k2+k3)/3
   k3,1,k2,1,k1,1: (k1+k2+k3)/3
 - v1=v2=1 et v3=0
   choisir une valeur k0
   - |m1-m2| < 5
     choisir 1 valeur k dans [4..1023]
     k,1,k-4,1,k0,O: (2k-4)/2
     k-4,1,k,1,k0,0: (2k-4)/2
     choisir 2 valeurs k1 et k2 dans [0..1023] telles que |k1-k2| < 4, permutez 
     sur les valeurs de m1 et m2 
     k1,1,k2,1,k,0: (k1+k2)/2
     k2,1,k1,1,k,0: (k1+k2)/2
   - |m1-m2| >= 5
     choisir 1 valeur k dans [5..1023], 
     k,1,k-5,1,k0,0: -(2k-5)/2
     k-5,1,k,1,k0,0: -(2k-5)/2
     choisir 2 valeurs k1 et k2 dans [0..1023] telles que |k1-k2| > 5,
     permutez sur  les valeurs de m1 et m2 
     k1,1,k2,1,k,0: -(k1+k2)/2
     k2,1,k1,1,k,0: -(k1+k2)/2
 - v1=v3=1 et v2=0
   idem, mutatis mutandis
 - v2=v3=1 et v1=0
   idem, mutatis mutandis
 - v1=1 et v2=v3=0
   choisir 2 valeur k et k'
   - m1 = 69
     69,1,k,0,k',0: -69
   - m1 < 69
     choisir k1 dans [0..69[
     k1,1,k,0,k',0: -k1
   - m1 = 70
     70,1,k,0,k',0:70
   - 70 < m1 < 950
     choisir k1 dans ]70..950[
     k1,1,k,0,k',0: k1
   - m1 = 949
     949,1,k,0,k',0:949
   - m1 = 950
     950,1,k,0,k',0:950
   - m1 = 951
     951,1,k,0,k',0:-951
   - 951 < m1
     choisir k1 dans ]951..1023]
     k1,1,k,0,k',0: -k1
 - v2=1 et v1=v3=0
   idem, mutatis mutandis
 - v3=1 et v1=v2=0
   idem, mutatis mutandis
 - v1=v2=v3=0
   choisir 3 valeurs k1,k2,k3 dans [0..1023], choisir k
   k1,0,k2,0,k3,0: -k