Discussion :

[Junta]

Bonjour,

J'avais fait un topic, il y a quelques temps, sur la validation de données avec le framework OVal, topic qui s'était avéré assez instructif. Aujourd'hui, je reviens sur la question de la validation de données, et celle des assertions (pré-condition, post-condition, invariant, ...)

Cas d'étude :
On souhaite réaliser une fonction simple qui affiche n fois un message à l'écran. Plusieurs contraintes doivent être respectées pour l'exécution de la fonction, faute de quoi on génère une exception.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
public void printMessage(String message, int loop) {
  for(int i=0; i<loop; i++) {
    System.out.println(message);
  }
}

Contraintes à respecter :
- Le message ne doit pas être nul ;
- Le nombre de répétitions doit être positif ou nul.

Après quelques recherches, j'ai trouvé qu'on pouvait faire ça de quatre manières différentes (au moins) :
- Avec des if(...)
- Avec des assert
- Avec les annotations java (framework OVal)
- Avec les méthodes de la classe Assert de JUnit

Mes impressions :
- J'ai quelques réticences avec les if parce qu'ils prennent pas mal de place dans le code (en comptant les accolades et un code correctement formatté).
- On peut désactiver les assert au moment de l'exécution du programme, ce qui pourrait permettre de faire sauter toutes les contraintes...
- Pour utiliser OVal, il faut utiliser la programmation par aspect, afin qu'un composant analyse les annotations et inspecte chaque méthode avant de l'exécuter, est-ce que ce n'est pas problématique au niveau des performances ?
- JUnit est, selon moi, réservé aux tests unitaires et non pas aux vérifications de cohérence

=> D'où ma question : au fond, quelle est la meilleure manière de faire des assertions en Java ? Laquelle utilisez-vous ? Laquelle déconseillez-vous ?

D'avance merci !

Junta

[gifffftane]

Moi je n'utilise jamais les assertions java, toujours des if pour les préconditions. Je VEUX que mes préconditions soient TOUJOURS vérifiées.

Certes, je ne mets pas beaucoup de préconditions... mais celles que je mets, au moins, qu'elles soient réalisées.

Il est exact, à mon avis, que JUnit ne sert pas aux vérifications de cohérence. Toutefois, il aide à empecher l'apparitition d'incohérences : un code sans bug génère, je suppose, des valeurs cohérentes. Et même je l'utilise pour vérifier comment mon code se comporte en cas d'incohérence.

Je fais un code assez permissif, sans aucune préoccupation pour la couverture de test, et encore moins pour vérifier si toutes les préconditions sont OK tout le temps. J'essaie seulement de trouver quelles sont les fonctions sensibles, et de vérifier seulement celles-là. Je trouve, peut être à tord, que c'est plus facile de le faire évoluer ainsi.