Assertions

Voir aussi :

• Utiliser les assertions par Sébastien Meric
• Utiliser les assertions avec Java 8 (documentation officielle - en anglais)
• Les assertions dans Node.js (documentation officielle - en anglais)

Introduction

Une assertion b est une expression booléenne supposée vraie. S'il s'avère que b est fausse, l'assertion est dite violée. Les assertions :

• servent à augmenter la lisibilité du code et sa fiabilité
• caractérisent l'ensemble des états (valeurs des attributs de l'objet et valeurs des paramètres de la méthode) que la méthode devrait savoir traiter correctement
• en général, expriment des faits qui ne peuvent pas être exprimés en utilisant les types de données de notre langage de programmation
• sont utilisées pour définir :
  • la pré-condition de méthode (condition nécessaire pour qu'un client soit autorisé à appeler cette méthode)
  • la post-condition de méthode (condition qui caractérise l'ensemble des états dans lequel la méthode laisse les objets de l'application)
  • l’invariant de classe (propriétés vraies pour l'ensemble des instances de la classe)
  • l’invariant de boucle (propriétés vraies pour chaque itération de la boucle)

Les assertions en Java

• Si une assertion est violée, une AssertionError est levée.
• Seulement les instances de la classe Throwable (or de ses sous-classes) peuvent être levées par throw
• Les assertions doivent être activées pour les utiliser lors de l'exécution (option -enableassertions, ou -ea, de la machine virtuelle). L'option -disableassertions, ou -da, est utilisée pour les désactiver

Hiérarchie des classes en Java

• Object
  • Throwable
    • Error
      • AssertionError
      • ...
    • Exception
      • RuntimeException
        • NullPointerException
        • IndexOutOfBoundsException
        • ...
      • IOException
      • ...
  • ...

Classification des erreurs

Les erreurs peuvent être fatales ou corrigibles. En général,

• les instances de la classe Error correspondent à des erreurs fatales.
• les instances de la classe Exception correspondent à des erreurs corrigibles et sont traitées dans le bloc try { ... } catch { ... }.

Exemples

Exemples de la forme assert expression1; de l'instruction d'assertion :

public int foo() {
  for(...) {
    ... return ...;
  }
  // on ne devrait jamais passer ici, Java
  // se plaint si pas de return
  assert false;
  return 0;
}

public int foo(int i) {
  assert i % 2 == 0;
  ...
}

Exemple de la forme assert expression1 : expression2; de l'instruction d'assertion pour définir un invariant interne. Cette forme permet de détailler le message d'erreur.

switch(x) {
  case ... : ... break;
  ...
  case ... : ... break;
  default : assert false: "x: " + x;
}

Même exemple que précédemment, sauf que l'erreur est ici levée par throw. De cette façon, l'erreur est lancée même si les assertions sont désactivées.

switch(x) {
  case ... : ... break;
  ...
  case ... : ... break;
  default : throw new AssertionError(x);
}

Exemple d'utilisation de l'assertion pour définir la pré-condition et la post-condition de méthode :

public static double racineCarree(double value){
  assert(value >= 0);  // pré-condition
  double res = ...;
  assert(abs(res * res - value) < eps);  // post-condition
  return resultat;
}

Exemple d'utilisation de l'assertion pour définir un invariant de boucle (ainsi que pour définir une pré et une post-condition de méthode) :

public class Assertions {
  public static int pgcd(int a, int b) {
    // pré-condition
    assert a >= 0 && b >= 0 : "Error a=" + a + " b=" + b;
    int u = a, v = b, r;

    do {
      // invariant de boucle
      assert v != 0;
      r = u % v;
      u = v;
      v = r;
    } while (r != 0);
    // post-condition
    assert a % u == 0 && b % u == 0 ;
    return u;
  }

  public static void main(String[] args) {
    System.out.println(pgcd(24, 20));
    System.out.println(pgcd(4, 8));
    System.out.println(pgcd(1, 4));
    System.out.println(pgcd(4, 1));
  }

}