Prototype + programme de démo + exécutable

Median3Entiers.lir

@@ -0,0 +1,37 @@
+10 affiche "Bienvenue dans le programme Median3Entiers.lir"
+20 affiche
+30 affiche "Entrez le premier entier : "
+40 entre premier
+50 affiche "Entrez le deuxième entier : "
+60 entre deuxieme
+70 affiche "Entrez le troisième entier : "
+80 entre troisieme
+90 procedure 1000
+100 affiche "Median( "
+110 affiche premier
+120 affiche ", "
+130 affiche deuxieme
+140 affiche ", "
+150 affiche troisieme
+160 affiche ") = "
+170 affiche median
+180 affiche
+250 stop
+
+1000 si premier <= deuxieme vaen 1100
+1010 si deuxieme <= troisieme vaen 1200
+1020 vaen 1520
+
+1100 si deuxieme <= troisieme vaen 1520
+1110 si premier <= troisieme vaen 1540
+1120 vaen 1500
+
+1200 si premier <= troisieme vaen 1500
+1220 vaen 1540
+
+1500 var median = premier
+1510 vaen 1550
+1520 var median = deuxieme
+1530 vaen 1550
+1540 var median = troisieme
+1550 retour

demo.lir

@@ -0,0 +1,13 @@
+10 affiche "Entre ton nom : " 
+20 entre $nom 
+30 affiche "Bienvenue "+$nom 
+35 affiche 
+40 var an=2021 
+50 affiche "Quelle est ton année de naissance ? " 
+60 entre naissance 
+65 si naissance > an vaen 50 
+70 affiche "Tu as autour de " 
+80 affiche an-naissance 
+90 affiche "ans " 
+100 affiche 
+200 stop

etatCivil.lir

@@ -0,0 +1,28 @@
+10 affiche "Bienvenue dans le programme"
+20 affiche
+30 var instant = 2021
+40 procedure 500
+50 var $message = "Vous êtes " + $prenom
+60 var $message = $message + " "
+65 var $message = $message + $nom
+70 affiche $message
+80 affiche
+90 affiche "age : "
+100 affiche age
+110 affiche " ans"
+120 vaen 150
+124 affiche
+125 affiche "erreur vaen si affiché"
+150 affiche
+200 affiche "Merci d'avoir utilisé ce programme !"
+400 stop
+500 affiche "Saisissez votre nom : "
+510 entre $nom
+520 affiche "Saisissez votre prénom : "
+530 entre $prenom
+540 affiche "Saisissez votre année de naissance (entier) : "
+550 entre naissance
+560 procedure 1000
+570 retour
+1000 var age = instant - naissance
+1010 retour

factorielle.lir

@@ -0,0 +1,35 @@
+10 affiche "Bienvenue dans le programme factorielle.lir !"
+20 affiche
+30 affiche "Entrez un entier : "
+40 entre entier
+45 procedure 500
+50 procedure 1000
+60 affiche entier
+70 affiche "! = "
+80 affiche factorielle
+90 affiche
+200 stop
+
+500 si entier >= 0 vaen 600
+510 affiche "n! est définie sur l'ensemble des entiers naturels"
+520 stop
+600 retour
+
+1000 var factorielle = 1
+1010 var entierCourant = 2
+1011 var ancienFactorielle = factorielle
+1012 var test = factorielle
+1015 si entierCourant > entier vaen 1100
+1016 si ancienFactorielle <> test vaen 1060
+1017 var ancienFactorielle = factorielle
+1020 var factorielle = factorielle * entierCourant
+1025 var test = factorielle / entierCourant
+1030 var entierCourant = entierCourant + 1
+1040 vaen 1015
+1050 vaen 1100
+1060 affiche "dépassement de la capacité des entiers pour "
+1070 affiche entier
+1080 affiche "!"
+1090 affiche
+1095 stop
+1100 retour

prototype/lanceInterpreteurLIR.bat

@@ -0,0 +1,2 @@
+java -jar interpreteurLIR.jar
+cmd /k java -jar interpreteurLIR.jar

src/interpreteurlir/Analyseur.java

@@ -143,6 +143,10 @@ public class Analyseur {
                                      .getConstructor(classeArg, classeContexte)
                                      .newInstance(arguments, contexteGlobal);
             feedback(cmd.executer());
+            if (motCle.equals("lance") 
+                    || (motCle.equals("affiche") && !arguments.isBlank())) {
+                System.out.println();
+            }
         } catch (  InvocationTargetException | IllegalAccessException 
                  | InstantiationException    | NoSuchMethodException 
                  | InterpreteurException     | ExecutionException lancee) {
@@ -213,14 +217,14 @@ public class Analyseur {
      * Recherche l'instruction correspondant au mot clé.
      * <ul><li>Les instructions doivent être 
      *         dans le package interpreteurlir.motscles.instructions</li>
-     * <ul>
+     * </ul>
      * La classe correspondant doit avoir un nom qui se finit avec le mot clé
      * (première lettre en majuscule)
      * @param motCle mot clé de l'instruction
      * @return Classe de cette instruction.
      * @throws InterpreteurException si motCle est vide, null ou non reconnue
      */
-    private static Class<?> rechercheInstruction(String motCle) {
+    public static Class<?> rechercheInstruction(String motCle) {
         final String ERREUR_VIDE = "ligne vide";
         final String ERREUR_INCONNU = "mot clé inconnu";
         final String CLASS_PATH_INST = 

src/interpreteurlir/Contexte.java

@@ -61,7 +61,6 @@ public class Contexte {
         }
         // else
         
-        
         Variable varAIndex = variables.get(indexVar);
         /* Variable déjà présente */
         if (varAIndex.getIdentificateur().compareTo(id) == 0) {

src/interpreteurlir/ExecutionException.java

@@ -14,6 +14,7 @@ package interpreteurlir;
  * @author Heïa Dexter
  * @author Lucas Vabre
  */
+@SuppressWarnings("serial")
 public class ExecutionException extends RuntimeException {
     
     /** 

src/interpreteurlir/InterpreteurException.java

@@ -13,6 +13,7 @@ package interpreteurlir;
  * @author Heïa Dexter
  * @author Lucas Vabre
  */
+@SuppressWarnings("serial")
 public class InterpreteurException extends RuntimeException {
     
     /** 

src/interpreteurlir/donnees/Identificateur.java

@@ -1,5 +1,5 @@
 /*
- * Identificateur.java , 08/05/2021
+ * Identificateur.java , 8 mai 2021
  * IUT Rodez 2020-2021, info1
  * pas de copyright, aucun droits
  */
@@ -9,31 +9,31 @@ package interpreteurlir.donnees;
 import interpreteurlir.InterpreteurException;
 
 /**
+ * Identificateur d'une variable.
  * @author Nicolas Caminade
  * @author Sylvan Courtiol
  * @author Pierre Debas
  * @author Heia Dexter
  * @author Lucas Vabre
  */
-public class Identificateur /* extends Variable */
-implements Comparable<Identificateur> {
+public abstract class Identificateur implements Comparable<Identificateur> {
 
     /** Longueur maximale d'un identificateur (ne prend pas en compte le $) */
     public static final int LONGUEUR_MAX = 25;
 
-    /** Nom identificateur */
+    /** Nom de cet identificateur */
     private String nom;
 
     /**
      * Instantiation de l'identificateur
-     * @param identificateur
+     * @param identificateur nom de l'identificateur
      */
     public Identificateur(String identificateur) {
         super();
         identificateur = identificateur.trim();
         if(!isIdentificateur(identificateur)) {
             throw new InterpreteurException(identificateur
-                    + " n'est pas un identificateur");
+                                            + " produit un résultat inattendu");
         }
 
         nom = identificateur;
@@ -46,7 +46,7 @@ implements Comparable<Identificateur> {
      *     <li>N'est pas une chaîne vide</li>
      *     <li>N'est pas null</li>
      * </ul>
-     * @param aTester
+     * @param aTester chaîne à tester
      * @return true si le prédicat est vérifié
      *         false sinon
      */
@@ -80,14 +80,12 @@ implements Comparable<Identificateur> {
              index < aTester.length()
              && Character.isLetterOrDigit(aTester.charAt(index)) ;
              index++)
-            ;    // Corps vide
+            ; /* empty body */
 
         return index >= aTester.length();
     }
 
-    /**
-     * @return la valeur de nom
-     */
+    /**  @return la valeur de nom */
     public String getNom() {
         return nom;
     }

src/interpreteurlir/donnees/IdentificateurChaine.java

@@ -39,7 +39,7 @@ public class IdentificateurChaine extends Identificateur {
      * @return true si l'identificateur est bien un identificateur d'entier
      *                 false sinon
      */
-    private static boolean isIdentificateurChaine(String identificateur) {
+    public static boolean isIdentificateurChaine(String identificateur) {
 
         return identificateur.length() >= 2
                 && identificateur.charAt(0) == '$'

src/interpreteurlir/donnees/IdentificateurEntier.java

@@ -21,10 +21,10 @@ import interpreteurlir.InterpreteurException;
 public class IdentificateurEntier extends Identificateur {
 
     /**
-     * Instantiation de cet identificateur d'entier avec le nom spécififié 
+     * Instantiation de cet identificateur d'entier avec le nom spécifié 
      * en argument. Lève une exception si l'identificateur n'est pas
      * valide.
-     * @param identificateur a instancier
+     * @param identificateur à instancier
      * @throws InterpreteurException si l'identificateur est invalide
      */
     public IdentificateurEntier(String identificateur) {
@@ -49,7 +49,7 @@ public class IdentificateurEntier extends Identificateur {
      * @return true si l'identificateur est bien un identificateur d'entier
      *                 false sinon
      */
-    private static boolean isIdentificateurEntier(String aTester) {
+    public static boolean isIdentificateurEntier(String aTester) {
         return aTester.length() <= 25 && Character.isLetter(aTester.charAt(0))
             && isAlphanumerique(aTester.substring(1));
     }

src/interpreteurlir/donnees/Variable.java

@@ -65,7 +65,7 @@ public class Variable extends Object implements Comparable<Variable> {
 
     /** 
      * Modifie la valeur de cette variable
-     * @param nouvelleValeur 
+     * @param nouvelleValeur valeur à affecter à cette variable
      */
     public void setValeur(Litteral nouvelleValeur) {
         if (isVariable(identificateur, nouvelleValeur)) {
@@ -86,6 +86,10 @@ public class Variable extends Object implements Comparable<Variable> {
         return identificateur.toString() + " = " + valeur.toString();
     }
 
+    /*
+     * non javadoc
+     * @see java.lang.Comparable#compareTo(java.lang.Object)
+     */
     public int compareTo(Variable aComparer) {
         return identificateur.compareTo(aComparer.identificateur);
     }

src/interpreteurlir/donnees/litteraux/Booleen.java

@@ -0,0 +1,48 @@
+/**
+ * Booleen.java                              21 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.donnees.litteraux;
+
+import interpreteurlir.InterpreteurException;
+
+/** 
+ * Constante littérale de type booléen
+ * 
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class Booleen extends Litteral {
+
+    /** 
+     * Initialise ce booléen
+     * @param unBooleen valeur du booléen à construire
+     * @throws InterpreteurException si la condition n'est pas un
+     *                               
+     */
+    public Booleen(Boolean unBooleen) {
+        super();
+        valeur = unBooleen;
+    }
+    
+    /* non javadoc
+     * @see interpreteurlir.donnees.litteraux.Litteral#getValeur()
+     */
+    @Override
+    public Boolean getValeur() {
+        return (Boolean) super.valeur;
+    }
+
+    /* non javadoc
+     * @deprecated
+     * @see Litteral#compareTo(Litteral)
+     */
+    @Override
+    public int compareTo(Litteral autre) {
+        return (Boolean)this.valeur == (Boolean)autre.valeur ? 0 : 1; // égalité
+    }
+
+}

src/interpreteurlir/donnees/litteraux/Chaine.java

@@ -21,11 +21,11 @@ public class Chaine extends Litteral {
         
         /** Erreur chaîne trop longue */
         private static final String ERREUR_LG_MAX = 
-                "Longueur maximale d'une chaîne dépassée";
+                "longueur maximale d'une chaîne dépassée";
         
         /** Erreur constante littéral chaîne invalide */
         private static final String ERREUR_INVALIDE = 
-                "syntaxe incorrecte pour une constante de type chaîne : ";
+                " n'est pas une constante de type chaîne";
         
         /**
          * initialise cette chaîne avec  une valeur par défaut.
@@ -35,14 +35,14 @@ public class Chaine extends Litteral {
         }
 
         /** 
-         * Initialise une chaîne avec la séquence de caractères passée en argument.
-         * @param uneValeur
+         * Initialise une chaîne avec la séquence 
+         * de caractères passée en argument.
+         * @param uneValeur valeur de la chaine à construire (entre guillemets)
          */
         public Chaine(String uneValeur) {
             uneValeur = uneValeur.trim();
-                if (!uneValeur.startsWith("\"") || !uneValeur.endsWith("\"")) {
-                    throw new InterpreteurException(ERREUR_INVALIDE 
-                                                    + uneValeur);
+            if (!isChaine(uneValeur)) {
+                throw new InterpreteurException(uneValeur + ERREUR_INVALIDE);
             }
 
             uneValeur = uneValeur.substring(1, uneValeur.length() - 1);
@@ -53,6 +53,17 @@ public class Chaine extends Litteral {
             valeur = uneValeur;
         }
 
+        /** 
+         * Prédicat de validité d'une constante littérale de type chaîne.
+         * @param uneValeur valeur aTester
+         * @return true si uneValeur est une chaîne sinon false
+         */
+        public static boolean isChaine(String uneValeur) {
+            uneValeur = uneValeur.trim();
+            return  uneValeur.length() >= 2 
+                    && uneValeur.startsWith("\"") && uneValeur.endsWith("\"");
+        }
+        
         /** 
          * Concatène deux chaînes ensemble. Opération non commutative: 
          * a + b != b + a
@@ -61,16 +72,15 @@ public class Chaine extends Litteral {
          * @return une nouvelle Chaîne.
          */
         public static Chaine concatener(Chaine a, Chaine b) {
-                
             return new Chaine("\"" + a.valeur + b.valeur + "\"");
         }
         
         /* non javadoc
-         * @see interpreteurlir.donnees.litteraux.Litteral#compareTo(interpreteurlir.donnees.litteraux.Litteral)
+         * @see Litteral#compareTo(Litteral)
          */
         @Override
         public int compareTo(Litteral autre) {
-                return this.valeur.toString().compareTo(autre.valeur.toString());
+                return valeur.toString().compareTo(autre.valeur.toString());
         }
 
         /* non javadoc

src/interpreteurlir/donnees/litteraux/Entier.java

@@ -18,72 +18,45 @@ import interpreteurlir.InterpreteurException;
  */
 public class Entier extends Litteral {
     
-    private static final int LONG_CH_MAX = 11;
-
-    /** Valeur entière minimale */
-    public static int VALEUR_MIN = Integer.MIN_VALUE;
-    
-    /** Valeur entière minimale */
-    public static int VALEUR_MAX = Integer.MAX_VALUE;
-    
     /** 
      * Initialisation de cet entier avec une valeur passée en argument
-     * @param unEntier
-     * @throws InterpreteurException lorsque entier n'est pas un Entier
+     * @param unEntier valeur de l'entier à construire
      */
-    @SuppressWarnings("boxing")
     public Entier(int unEntier) {
     
-        if (! isEntier(unEntier)) {
-            throw new InterpreteurException("Erreur. " + unEntier 
-                                            + " n'est pas un entier. ");
-        }
         super.valeur = unEntier;
     }
 
     /** 
      * Initialisation de cet entier avec une valeur passée en argument
-     * @param uneValeur 
+     * @param uneValeur chaîne contenant l'entier à construire
      */
     public Entier(String uneValeur) {
         if (!isEntier(uneValeur)) {
             throw new InterpreteurException(uneValeur 
-                                            + " n'est pas un nombre entier. ");
+                                            + " n'est pas un nombre entier");
         }
 
         valeur = Integer.valueOf(uneValeur);
     }
     
-    private static boolean isEntier(String uneValeur) {
-        if (uneValeur != null && !uneValeur.isBlank() 
-            && uneValeur.length() <= LONG_CH_MAX
-            && (isChiffre(uneValeur.charAt(0)) 
-                || uneValeur.length() > 1 && (uneValeur.charAt(0) == '-' 
-                                           || uneValeur.charAt(0) == '+'))) {
-          int i;
-          for (i = 1; i < uneValeur.length() && isChiffre(uneValeur.charAt(i)); 
-               i++)
-              ; /* corps vide */
-          if ((uneValeur.startsWith("+214748364") 
-                  || uneValeur.startsWith("214748364"))
-                  && uneValeur.charAt(uneValeur.length() - 1) > '7'
-              || uneValeur.startsWith("-214748364") 
-                  && uneValeur.charAt(uneValeur.length() - 1) > '8'
-                  )
-                      return false;
-          
-          return i >= uneValeur.length();
-        }
-        
+    /** 
+     * Prédicat de validité d'une chaîne en tant que nombre entier signé
+     * @param uneValeur la chaîne à tester
+     * @return true si uneValeur est un entier sinon false
+     */
+    public static boolean isEntier(String uneValeur) {
+        if (uneValeur == null) {
             return false;
         }
         
-    private static boolean isChiffre(char caractere) {
-        return '0' <= caractere && caractere <= '9';
+        try {
+            Integer.valueOf(uneValeur.trim());
+        } catch (NumberFormatException lancee) {
+            return false;
         }
         
-    private static boolean isEntier(int entier) {
-        return VALEUR_MIN <= entier && entier <= VALEUR_MAX;
+        return true;
     }
 
     /* non javadoc
@@ -101,10 +74,10 @@ public class Entier extends Litteral {
 
     /** 
      * Compare cet entier à un autre entier
-     * @param autre
-     * @return une valeur < 0 lorsque autre > cet entier
-     *         une valeur > 0 lorsque autre < cet entier
-     *         une valeur = 0 lorsque autre et cet entier sont égaux
+     * @param autre entier avec lequel this est comparé
+     * @return une {@code valeur < 0} lorsque {@code autre > cet entier}
+     *         une {@code valeur > 0} lorsque {@code autre < cet entier}
+     *         une {@code valeur = 0} lorsque autre et cet entier sont égaux
      */
     public int compareTo(Entier autre) {
         return ((Integer) valeur).compareTo(autre.getValeur());
@@ -151,7 +124,7 @@ public class Entier extends Litteral {
      */
     public static Entier quotient(Entier premier, Entier second) {
         if (second.compareTo(new Entier (0)) == 0) {
-            throw new ExecutionException("Erreur. Division par 0. ");
+            throw new ExecutionException("division par 0");
         }
         return new Entier((int) premier.getValeur() / (int) second.getValeur());
     }
@@ -165,8 +138,16 @@ public class Entier extends Litteral {
      */
     public static Entier reste(Entier premier, Entier second) {
         if (second.compareTo(new Entier (0)) == 0) {
-            throw new ExecutionException("Erreur. Division par 0. ");
+            throw new ExecutionException("division par 0");
         }
         return new Entier((int) premier.getValeur() % (int) second.getValeur());
     }
+
+    /* non javadoc
+     * @see Litteral#compareTo(Litteral)
+     */
+    @Override
+    public int compareTo(Litteral autre) {
+        return ((Integer)valeur).compareTo((Integer)autre.valeur);
+    }
 }

src/interpreteurlir/donnees/litteraux/Litteral.java

@@ -13,7 +13,7 @@ package interpreteurlir.donnees.litteraux;
  * @author Heïa Dexter
  * @author Lucas Vabre
  */
-public class Litteral implements Comparable<Litteral> {  
+public abstract class Litteral implements Comparable<Litteral> {  
         
         /** valeur de ce littéral */
         protected Object valeur;
@@ -27,9 +27,9 @@ public class Litteral implements Comparable<Litteral> {
 
         /** 
          * Initialise cette valeur avec un objet argument.
-         * @param valeur
+         * @param valeur valeur du littéral à construire
          */
-        public Litteral(Object valeur) {  // TODO public >>> protected
+        public Litteral(Object valeur) {
                 super();
                 this.valeur = valeur;
         }
@@ -53,11 +53,5 @@ public class Litteral implements Comparable<Litteral> {
          * @see java.lang.Comparable#compareTo(java.lang.Object)
          */
         @Override
-        public int compareTo(Litteral autre) {
-                
-                if (autre.valeur.getClass() == this.valeur.getClass())
-                    return 0;
-                
-                return this.valeur.hashCode() - autre.valeur.hashCode();
-        }
+        public abstract int compareTo(Litteral autre);
 }

src/interpreteurlir/donnees/litteraux/tests/TestBooleen.java

@@ -0,0 +1,50 @@
+/**
+ * TestBooleen.java                              21 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.donnees.litteraux.tests;
+
+import interpreteurlir.donnees.litteraux.Booleen;
+import static info1.outils.glg.Assertions.*;
+
+/** 
+ * Tests unitaires des méthodes de la classe Booleen
+ * 
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class TestBooleen {
+    
+    private static final Booleen[] FIXTURE = {
+        new Booleen(false),
+        new Booleen(true),
+        new Booleen(1<2),
+        new Booleen(1>=2),
+        new Booleen("bob".equals("bob")),
+        new Booleen(Character.isDigit('a')),
+        new Booleen(!Double.isNaN(1/0.0)),
+    };
+    
+    /** 
+     * Tests unitaire de {@link Booleen#getValeur()}
+     */
+    public void testGetValeur() {
+        final Boolean[] ATTENDUS = {
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true
+        };
+        System.out.println("\tExécution du test de getValeur");
+        for (int i = 0 ; i < ATTENDUS.length ; i++) {
+            assertTrue(ATTENDUS[i].compareTo(FIXTURE[i].getValeur())
+                       == 0);
+        }
+    }
+}

src/interpreteurlir/donnees/litteraux/tests/TestChaine.java

@@ -10,7 +10,8 @@ import interpreteurlir.donnees.litteraux.Chaine;
 import static info1.outils.glg.Assertions.*;
 
 /**  
- * Tests unitaires de Chaine
+ * Tests unitaires de la classe Chaine
+ * 
  * @author Nicolas Caminade
  * @author Sylvan Courtiol
  * @author Pierre Debas
@@ -20,13 +21,14 @@ import static info1.outils.glg.Assertions.*;
 public class TestChaine {
 
 
-	/** test de Chaine(String) */
+    /** Test unitaire de {@link Chaine#Chaine(String)} */
     public static void testChaine() {
 
         final String[] VALIDE = { 
                 "\"arztyehjklmpoijhghnbghjklmpoiuytrf" + 
                         "ghjnklmpoiuytrezaqsdfghnjklmpjbfrtyu\"", 
-			"\"\"","\"coucou \"",
+                "\"\"",
+                "\"coucou \"",
                 "\"" + 42 + "\""
         };  
 
@@ -34,89 +36,82 @@ public class TestChaine {
                 "arztyehjklmpoijhghnbghjklmpoiuytrf" + 
                         "yeryghjnklmpoiuytrezaqsdfghnjklmpjbfrtyu";
 
-	    System.out.println("test de Chaine(String)");
+        System.out.println("\tExécution du test de Chaine(String)");
 
-	    for (String aTester : VALIDE)
+        for(String aTester : VALIDE) {
+            try {
                 new Chaine(aTester);
+            } catch (InterpreteurException lancee) {
+                echec();
+            }
+        }
 
         try {
             new Chaine(INVALIDE);
-	    	throw new RuntimeException("Instanciation interdite");
+            echec();
         } catch (InterpreteurException lancee) {
-	    	System.out.println("Revoi d'exception OK\nfin du test");
+            // Test OK
         }
     }
 
-	/** test  de compareTo */
+    /** Test unitaire de {@link Chaine#compareTo(Litteral)} */
     public static void testCompareTo() {
         final Chaine[][] EGALITES = { 
-			{new Chaine("\"coucou\""), new Chaine("\"coucou\"")}, 
-			{new Chaine("\" \""), new Chaine("\" \"")},
-			{new Chaine("\"\""), new Chaine()} 
+                { new Chaine("\"coucou\""), new Chaine("\"coucou\"") }, 
+                { new Chaine("\" \""), new Chaine("\" \"") },
+                { new Chaine("\"\""), new Chaine() } 
         };
 
         final Chaine[][] DIFFERENCES = { 
-			{new Chaine("\"coucou\""), new Chaine("\"camomille\"")},
-			{new Chaine("\"tarentule\""), new Chaine("\"coucou\"")}, 
-			{new Chaine("\"coucou\""), new Chaine("\" \"")}, 
-			{new Chaine("\"coucou\""), new Chaine()},
-			{new Chaine("\" \""), new Chaine()} 
+                { new Chaine("\"coucou\""), new Chaine("\"camomille\"") },
+                { new Chaine("\"tarentule\""), new Chaine("\"coucou\"") }, 
+                { new Chaine("\"coucou\""), new Chaine("\" \"") }, 
+                { new Chaine("\"coucou\""), new Chaine() },
+                { new Chaine("\" \""), new Chaine() } 
         };
 
-		System.out.println("test de compareTo(Chaine)\nAvec égalités");
+        System.out.println("\tExécution du test de compareTo(Chaine)\n"
+                            + "\tAvec égalités");
 
         for (Chaine[] couple : EGALITES) {
-			
-			try {
-		    	assert couple[0].compareTo(couple[1]) == 0;
-		    } catch (AssertionError lancee) {
-				System.err.println("Echec du test");
+            assertEquivalence(couple[0].compareTo(couple[1]), 0);
         }
 
-		}
-		
-		System.out.println("Avec des inégalités");
+        System.out.println("\tAvec des inégalités");
         for (Chaine[] couple : DIFFERENCES) {
-			try {
-		    	assert couple[0].compareTo(couple[1]) > 0;
-		    } catch (AssertionError lancee) {
-				System.err.println("Echec du test");
+            assertTrue(couple[0].compareTo(couple[1]) > 0);
         }
     }
-		System.out.println("fin du test");
-	
-	}
 
-	/** test de toString */
+    /** Test unitaire de {@link Chaine#toString()} */
     public static void testToString() {
         final Chaine[] A_AFFICHER = {
-			new Chaine(), new Chaine("\" \""), 
+                new Chaine(), 
+                new Chaine("\" \""), 
                 new Chaine("\"coucou\""),
                 new Chaine("\" coucou \""), 
                 new Chaine("\"coucou monsieur\"")
         };
 
         final String[] AFFICHAGE_GUILLEMETS = {
-				"\"\"", "\" \"", "\"coucou\"", "\" coucou \"",
+                "\"\"", 
+                "\" \"", 
+                "\"coucou\"", 
+                "\" coucou \"",
                 "\"coucou monsieur\""
         };
 
-		System.out.println("test de toString");
+        System.out.println("\tExécution du test de toString");
         for (int i = 0 ; i < A_AFFICHER.length ; i++) {
-			
-			try {
-				assert A_AFFICHER[i].toString().equals(AFFICHAGE_GUILLEMETS[i]);
-			} catch (AssertionError lancee) {
-				System.err.println("Echec du test a l'indice " + i);
+            assertTrue(AFFICHAGE_GUILLEMETS[i]
+                        .equals(A_AFFICHER[i].toString()));
         }
     }
-		System.out.println("==>test terminé\n");		
-	}
 
     /**
      * Tests unitaires de concaténer
      */
-	public void testConcatener() {
+    public static void testConcatener() {
         final Chaine[] ATTENDU = {
                 new Chaine(),
                 new Chaine("\"Bonjour le monde ! \""),
@@ -125,27 +120,17 @@ public class TestChaine {
         };
 
         final Chaine[][] A_CONCATENER = {
-	        {new Chaine(), new Chaine("\"\"")},   
-	        {new Chaine("\"Bonjour \""), new Chaine("\"le monde ! \"")},
-	        {new Chaine("\"\""), new Chaine("\" \"")},
-	        {new Chaine("\"3,\""), new Chaine("\"1415\"")},
+                { new Chaine(), new Chaine("\"\"") },   
+                { new Chaine("\"Bonjour \""), new Chaine("\"le monde ! \"") },
+                { new Chaine("\"\""), new Chaine("\" \"") },
+                { new Chaine("\"3,\""), new Chaine("\"1415\"") },
         };
 
         System.out.println("\tExécution du test de concaténer");
         for (int numTest = 0 ; numTest < ATTENDU.length ; numTest++ ) {
-	        assertTrue(ATTENDU[numTest].compareTo(Chaine.concatener(
-	                   A_CONCATENER[numTest][0], A_CONCATENER[numTest][1])) 
-	                   == 0);
+            assertTrue(ATTENDU[numTest].compareTo(
+                           Chaine.concatener(A_CONCATENER[numTest][0], 
+                                   A_CONCATENER[numTest][1])) == 0);
         }
     }
-	
-	/** 
-	 * Lancement des tests
-	 * @param args non utilisés
-	 */
-	public static void main(String[] args) {
-		testChaine();
-		testCompareTo();
-		testToString();
-	}
 }

src/interpreteurlir/donnees/litteraux/tests/TestEntier.java

@@ -40,22 +40,6 @@ public class TestEntier {
         new Entier(179892),
     };
     
-    /** Jeu d'entiers correctement instanciés */
-    private final Entier[] ENTIERS_STRING = {
-
-        new Entier("1"),
-        new Entier("-4587"),
-        new Entier("-569"),
-        new Entier("-3"),
-        new Entier("0"),
-        new Entier("2"),
-        new Entier("78"),
-        new Entier("781"),
-        new Entier("179892"),
-        new Entier("-2147483648"),
-        new Entier("2147483647"),
-    };
-    
     /** Jeu d'integers correspondants */
     private static final int[] INT_VALIDES = {
         MIN_VALUE,
@@ -94,6 +78,7 @@ public class TestEntier {
                 "+",
         };
         
+        System.out.println("\tExécution du test de Entier(String)");
         for (int i = 0; i < INVALIDES.length; i++) {
             try {
                 new Entier(INVALIDES[i]);
@@ -108,6 +93,7 @@ public class TestEntier {
      * Test unitaire de la méthode toString()
      */
     public void testToString() {
+        System.out.println("\tExécution du test de Entier(String)");
         for (int i = 0; i < INT_VALIDES.length; i ++) {
             assertTrue(ENTIERS_INT[i].toString()
                        .compareTo(Integer.toString(INT_VALIDES[i])) == 0);
@@ -115,12 +101,12 @@ public class TestEntier {
     }
     
     /** 
-     * Test unitaire de la méthode toCompareTo()
+     * Test unitaire de la méthode compareTo()
      */
     public void testCompareTo() {
         final Entier REF_MIN = new Entier(MIN_VALUE);
         final Entier REF_MAX = new Entier(MAX_VALUE);
-        
+        System.out.println("\tExécution du test de compareTo()");
         for (int i = 2; i < ENTIERS_INT.length; i++) {
             assertTrue(REF_MIN.compareTo(ENTIERS_INT[i]) < 0);
             assertTrue(REF_MAX.compareTo(ENTIERS_INT[i]) > 0);
@@ -149,14 +135,14 @@ public class TestEntier {
                 781,
                 179892,
         };
-        
+        System.out.println("\tExécution du test de getValeur()");
         for (int i = 0; i < ENTIERS_INT.length; i++) {
             assertTrue(ENTIERS_INT[i].getValeur().compareTo(ATTENDUS[i]) == 0);
         }
     }
     
     /** 
-     * Test unitaire de la méthode somme()
+     * Test unitaire de la méthode somme(Entier, Entier)
      */
     public void testSomme() {
         final Entier[] ATTENDUS = {
@@ -172,7 +158,7 @@ public class TestEntier {
                 new Entier(1562),
                 new Entier(359784),
         };
-        
+        System.out.println("\tExécution du test de somme(Entier, Entier)");
         for (int i = 0; i < ENTIERS_INT.length; i++) {
             assertTrue(somme(ENTIERS_INT[i], ENTIERS_INT[i])
                        .compareTo(ATTENDUS[i]) == 0);
@@ -184,7 +170,7 @@ public class TestEntier {
      */
     public void testSoustrait() {
         Entier zero = new Entier(0); 
-        
+        System.out.println("\tExécution du test de soustrait(Entier, Entier)");
         for (int i = 0; i < ENTIERS_INT.length; i++) {
             assertTrue(soustrait(ENTIERS_INT[i], ENTIERS_INT[i])
                        .compareTo(zero) == 0);
@@ -208,7 +194,7 @@ public class TestEntier {
                 new Entier(781 * 781),
                 new Entier(179892 * 179892),
         };
-        
+        System.out.println("\tExécution du test de multiplie(Entier, Entier)");
         for (int i = 0; i < ENTIERS_INT.length; i++) {
             assertTrue(multiplie(ENTIERS_INT[i], ENTIERS_INT[i])
                        .compareTo(ATTENDUS[i]) == 0);
@@ -234,7 +220,7 @@ public class TestEntier {
                 new Entier(390),
                 new Entier(89946)
         };
-        
+        System.out.println("\tExécution du test de quotient(Entier, Entier)");
         for (int i = 0; i < ENTIERS_INT.length; i++) {
             assertTrue(quotient(ENTIERS_INT[i], DIVISEUR)
                        .compareTo(ATTENDUS[i]) == 0);
@@ -246,7 +232,8 @@ public class TestEntier {
      */
     public void testQuotientParZero() {
         final Entier DIVISEUR = new Entier(0);
-        
+        System.out.println("\tExécution du test de "
+                           + "quotient(Entier, Entier) par 0");
         for (int i = 0; i < ENTIERS_INT.length; i++) {
             try {
                 quotient(ENTIERS_INT[i], DIVISEUR);
@@ -276,7 +263,7 @@ public class TestEntier {
                 new Entier(1),
                 new Entier(0)
         };
-        
+        System.out.println("\tExécution du test de reste(Entier, Entier)");
         for (int i = 0; i < ENTIERS_INT.length; i++) {
             assertTrue(reste(ENTIERS_INT[i], DIVISEUR)
                        .compareTo(ATTENDUS[i]) == 0);
@@ -288,7 +275,8 @@ public class TestEntier {
      */
     public void testResteParZero() {
         final Entier DIVISEUR = new Entier(0);
-        
+        System.out.println("\tExécution du test de "
+                           + "reste(Entier, Entier) par 0");
         for (int i = 0; i < ENTIERS_INT.length; i++) {
             try {
                 reste(ENTIERS_INT[i], DIVISEUR);

src/interpreteurlir/donnees/litteraux/tests/TestLitteraux.java

@@ -1,171 +1,172 @@
-/**
- * TestLitteraux.java                                    7 mai 2021
- * IUT info1 2020-2021, pas de copyright, aucun droit
- */
-package interpreteurlir.donnees.litteraux.tests;
-
-import interpreteurlir.donnees.litteraux.Litteral;
-
-/**  
- * Test unitaires des constantes littérales de l'interpréteurlir
- * @author Nicolas Caminade
- * @author Sylvan Courtiol
- * @author Pierre Debas
- * @author Heïa Dexter
- * @author Lucas Vabre
- */
-public class TestLitteraux {	
-	
-	/**  Jeux de littéraux pour test. */
-	private static final Litteral[] VALIDES = {
-			/* Caractères */
-			new Litteral('a'),
-			new Litteral('!'),
-			new Litteral('\"'),
-			new Litteral('1'),
-			new Litteral('\t'),
-			/* Chaînes */
-			new Litteral("ceci est une chaine"),
-			new Litteral("bonjour"),
-			new Litteral(" bonjour "),
-			new Litteral(""),
-			new Litteral(" "),
-			/* Entier */
-			new Litteral(123),
-			new Litteral(-123),
-			new Litteral(0),
-			new Litteral(Integer.MAX_VALUE),
-			/* Double */
-			new Litteral(14.258),
-			new Litteral(-14.128),
-			new Litteral(0.0),
-			new Litteral(Double.NaN),
-			new Litteral(Double.NEGATIVE_INFINITY),
-			new Litteral(Double.MAX_VALUE),
-			new Litteral(Double.MIN_VALUE),
-			new Litteral(Double.MIN_NORMAL),
-			/* Boolean */
-			new Litteral(true),
-			new Litteral(false),
-			new Litteral(3 >= 4),
-			new Litteral(true),
-			new Litteral(true),
-			new Litteral(true)
-	};
-
-	/** test de getValeur */
-	public static void testGetValeur() {
-		
-		final Object[] VALEURS_ATTENDUES = {
-			'a', '!', '\"', '1', '\t' ,"ceci est une chaîne", "bonjour",
-			" bonjour ", "", " ", 123, -123, 0, 2147483647, 14.258, -14.128,
-			0.0, Double.NaN, Double.NEGATIVE_INFINITY, Double.MAX_VALUE,
-			Double.MIN_VALUE, Double.MIN_NORMAL, true, false, false, true, true,
-			true
-		};
-		
-		System.out.println("test de getValeur\n");
-		
-		for (int i = 0 ; i < VALIDES.length ; i++) {
-			
-			try {
-			    assert (VALIDES[i].getValeur().equals(VALEURS_ATTENDUES[i]));
-			} catch (AssertionError lancee) {
-				System.err.println("Echec du test a l'indice " + i);
-			}
-		}	
-		System.out.println("==>test terminé\n");
-	}
-	
-	/** test de toString */
-	public static void testToString() {
-		
-		final String[] STRING_ATTENDUE = {
-			"a", "!", "\"", "1", "\t", "ceci est une chaîne", "bonjour", 
-			" bonjour ", "", " ", "123", "-123", "0", "2147483647", "14.258",
-			"-14.128", "0.0", "NaN", "-Infinity", "1.7976931348623157E308",
-			"4.9E-324", "2.2250738585072014E-308", "true", "false", "false", 
-			"true", "true", "true"
-		};
-		
-		System.out.println("test de toString\n");
-		
-		for (int i = 0 ; i < VALIDES.length ; i++ ) {
-			
-			try {
-				assert (VALIDES[i].toString().equals(STRING_ATTENDUE[i]));
-			} catch (AssertionError lancee) {
-				System.err.println("Echec du test a l'indice " + i);
-			}
-		}
-		System.out.println("==>test terminé\n");
-	}
-	
-	/** test de compareTo */
-	public static void testCompareTo() {
-		
-		final Litteral[] MEMES_TYPES = {
-			new Litteral('a'),
-			new Litteral('!'),
-			new Litteral('\"'),
-			new Litteral('Z'),
-			new Litteral('s'),
-			new Litteral("bonjour"),
-			new Litteral("bonjour"),
-			new Litteral("arar"),
-			new Litteral("zarar za "),
-			new Litteral("CAFE_BABE"),
-			new Litteral(123),
-			new Litteral(123),
-			new Litteral(0),
-			new Litteral(-123),
-			new Litteral(Double.MAX_VALUE),
-			new Litteral(Double.NaN),
-			new Litteral(12.3),
-			new Litteral(Double.NaN),
-			new Litteral(45.7),
-			new Litteral(-12.6),
-			new Litteral(0.0),
-			new Litteral(Double.MIN_NORMAL),
-			new Litteral(false),
-			new Litteral(false),
-			new Litteral(true),
-			new Litteral(true),
-			new Litteral(true),
-			new Litteral(true)
-		};
-		
-		System.out.println("test de compareTo\nAvec des types identiques");
-		
-		for (int i = 0 ; i < VALIDES.length ; i++ ) {
-			
-			try {
-				assert (VALIDES[i].compareTo(MEMES_TYPES[i]) == 0);
-			} catch (AssertionError lancee) {
-				System.err.println("Echec du test a l'indice " + i);
-			}
-		}
-		System.out.println("Avec des types différents");
-		
-		for (int i = 0 ; i < VALIDES.length ; i++ ) {
-			
-			try {
-				assert (VALIDES[i].compareTo(MEMES_TYPES[MEMES_TYPES.length
-				                                         - (i + 1)]) != 0);
-			} catch (AssertionError lancee) {
-				System.err.println("Echec du test a l'indice " + i);
-			}
-		}
-		System.out.println("==>test terminé\n");
-	}
-	
-	/**
-	 * Lancement des test
-	 * @param args non utilisé 
-	 */
-	public static void main(String[] args) {
-		testGetValeur();
-		testToString();
-		testCompareTo();
-	}
-}
+// Classe testée passé en abstract
+///**
+// * TestLitteraux.java                                    7 mai 2021
+// * IUT info1 2020-2021, pas de copyright, aucun droit
+// */
+//package interpreteurlir.donnees.litteraux.tests;
+//
+//import interpreteurlir.donnees.litteraux.Litteral;
+//
+///**  
+// * Test unitaires des constantes littérales de l'interpréteurlir
+// * @author Nicolas Caminade
+// * @author Sylvan Courtiol
+// * @author Pierre Debas
+// * @author Heïa Dexter
+// * @author Lucas Vabre
+// */
+//public class TestLitteraux {	
+//	
+//	/**  Jeux de littéraux pour test. */
+//	private static final Litteral[] VALIDES = {
+//			/* Caractères */
+//			new Litteral('a'),
+//			new Litteral('!'),
+//			new Litteral('\"'),
+//			new Litteral('1'),
+//			new Litteral('\t'),
+//			/* Chaînes */
+//			new Litteral("ceci est une chaine"),
+//			new Litteral("bonjour"),
+//			new Litteral(" bonjour "),
+//			new Litteral(""),
+//			new Litteral(" "),
+//			/* Entier */
+//			new Litteral(123),
+//			new Litteral(-123),
+//			new Litteral(0),
+//			new Litteral(Integer.MAX_VALUE),
+//			/* Double */
+//			new Litteral(14.258),
+//			new Litteral(-14.128),
+//			new Litteral(0.0),
+//			new Litteral(Double.NaN),
+//			new Litteral(Double.NEGATIVE_INFINITY),
+//			new Litteral(Double.MAX_VALUE),
+//			new Litteral(Double.MIN_VALUE),
+//			new Litteral(Double.MIN_NORMAL),
+//			/* Boolean */
+//			new Litteral(true),
+//			new Litteral(false),
+//			new Litteral(3 >= 4),
+//			new Litteral(true),
+//			new Litteral(true),
+//			new Litteral(true)
+//	};
+//
+//	/** test de getValeur */
+//	public static void testGetValeur() {
+//		
+//		final Object[] VALEURS_ATTENDUES = {
+//			'a', '!', '\"', '1', '\t' ,"ceci est une chaîne", "bonjour",
+//			" bonjour ", "", " ", 123, -123, 0, 2147483647, 14.258, -14.128,
+//			0.0, Double.NaN, Double.NEGATIVE_INFINITY, Double.MAX_VALUE,
+//			Double.MIN_VALUE, Double.MIN_NORMAL, true, false, false, true, true,
+//			true
+//		};
+//		
+//		System.out.println("test de getValeur\n");
+//		
+//		for (int i = 0 ; i < VALIDES.length ; i++) {
+//			
+//			try {
+//			    assert (VALIDES[i].getValeur().equals(VALEURS_ATTENDUES[i]));
+//			} catch (AssertionError lancee) {
+//				System.err.println("Echec du test a l'indice " + i);
+//			}
+//		}	
+//		System.out.println("==>test terminé\n");
+//	}
+//	
+//	/** test de toString */
+//	public static void testToString() {
+//		
+//		final String[] STRING_ATTENDUE = {
+//			"a", "!", "\"", "1", "\t", "ceci est une chaîne", "bonjour", 
+//			" bonjour ", "", " ", "123", "-123", "0", "2147483647", "14.258",
+//			"-14.128", "0.0", "NaN", "-Infinity", "1.7976931348623157E308",
+//			"4.9E-324", "2.2250738585072014E-308", "true", "false", "false", 
+//			"true", "true", "true"
+//		};
+//		
+//		System.out.println("test de toString\n");
+//		
+//		for (int i = 0 ; i < VALIDES.length ; i++ ) {
+//			
+//			try {
+//				assert (VALIDES[i].toString().equals(STRING_ATTENDUE[i]));
+//			} catch (AssertionError lancee) {
+//				System.err.println("Echec du test a l'indice " + i);
+//			}
+//		}
+//		System.out.println("==>test terminé\n");
+//	}
+//	
+//	/** test de compareTo */
+//	public static void testCompareTo() {
+//		
+//		final Litteral[] MEMES_TYPES = {
+//			new Litteral('a'),
+//			new Litteral('!'),
+//			new Litteral('\"'),
+//			new Litteral('Z'),
+//			new Litteral('s'),
+//			new Litteral("bonjour"),
+//			new Litteral("bonjour"),
+//			new Litteral("arar"),
+//			new Litteral("zarar za "),
+//			new Litteral("CAFE_BABE"),
+//			new Litteral(123),
+//			new Litteral(123),
+//			new Litteral(0),
+//			new Litteral(-123),
+//			new Litteral(Double.MAX_VALUE),
+//			new Litteral(Double.NaN),
+//			new Litteral(12.3),
+//			new Litteral(Double.NaN),
+//			new Litteral(45.7),
+//			new Litteral(-12.6),
+//			new Litteral(0.0),
+//			new Litteral(Double.MIN_NORMAL),
+//			new Litteral(false),
+//			new Litteral(false),
+//			new Litteral(true),
+//			new Litteral(true),
+//			new Litteral(true),
+//			new Litteral(true)
+//		};
+//		
+//		System.out.println("test de compareTo\nAvec des types identiques");
+//		
+//		for (int i = 0 ; i < VALIDES.length ; i++ ) {
+//			
+//			try {
+//				assert (VALIDES[i].compareTo(MEMES_TYPES[i]) == 0);
+//			} catch (AssertionError lancee) {
+//				System.err.println("Echec du test a l'indice " + i);
+//			}
+//		}
+//		System.out.println("Avec des types différents");
+//		
+//		for (int i = 0 ; i < VALIDES.length ; i++ ) {
+//			
+//			try {
+//				assert (VALIDES[i].compareTo(MEMES_TYPES[MEMES_TYPES.length
+//				                                         - (i + 1)]) != 0);
+//			} catch (AssertionError lancee) {
+//				System.err.println("Echec du test a l'indice " + i);
+//			}
+//		}
+//		System.out.println("==>test terminé\n");
+//	}
+//	
+//	/**
+//	 * Lancement des test
+//	 * @param args non utilisé 
+//	 */
+//	public static void main(String[] args) {
+//		testGetValeur();
+//		testToString();
+//		testCompareTo();
+//	}
+//}

src/interpreteurlir/donnees/tests/TestIdentificateur.java

@@ -1,115 +1,118 @@
-/**
- * TestIdentificateur.java                                        8 mai 2021
- * IUT-Rodez info1 2020-2021, pas de droits, pas de copyrights
- */
-package interpreteurlir.donnees.tests;
+// Classe testée passé en abstract
 
-import static info1.outils.glg.Assertions.*;
+///**
+// * TestIdentificateur.java                                        8 mai 2021
+// * IUT-Rodez info1 2020-2021, pas de droits, pas de copyrights
+// */
+//package interpreteurlir.donnees.tests;
+//
+//import static info1.outils.glg.Assertions.*;
+//
+//import interpreteurlir.InterpreteurException;
+//import interpreteurlir.donnees.Identificateur;
+//
+///**
+// * Test de la classe donnees.Identificateur
+// * @author Nicolas Caminade
+// * @author Sylvan Courtiol
+// * @author Pierre Debas
+// * @author Heia Dexter
+// * @author Lucas Vabre
+// */
+//public class TestIdentificateur {
+//    
+//    /** Jeu d'identificateurs correctement instanciés  */
+//    public static final Identificateur[] FIXTURE = {
+//        new Identificateur("b"),
+//        new Identificateur("A"),
+//        new Identificateur("zalpha"),
+//        new Identificateur("Alpha"),
+//        new Identificateur("Alpha5"),
+//        new Identificateur("jeSuisUnTresLongIdentifi"),
+//        new Identificateur("$b"),
+//        new Identificateur("z"),
+//        new Identificateur("$zalpha"),
+//        new Identificateur("$Alpha"),
+//        new Identificateur("$Alpha5"),
+//        new Identificateur("$jeSuisUnTresLongIdentifi")
+//            
+//    };
+//    
+//    /**
+//     * Test de Identificateur(String identificateur)
+//     */
+//    public static void testIdentificateurString() {
+//        final String[] INVALIDE = {
+//            null,
+//            "",
+//
+//            // Fait au maximum 25 caractères
+//            "$jeSuisUnTresLongIdentificateur", // 30 char
+//            "$jeSuisUnTresLongIdentifica",
+//
+//            // Espaces
+//            "id 3a",
+//            "$id 3a",
+//            " ",
+//            "$ ",
+//
+//            // caractères d'échapements
+//            "\t",
+//            "\n",
+//            "$\t",
+//            "$\n",
+//
+//            // , cas particulier
+//            "$"
+//        };
+//        
+//        for(int noJeu = 0 ; noJeu < INVALIDE.length ; noJeu++) {
+//            try {
+//                new Identificateur(INVALIDE[noJeu]);
+//                echec();
+//            } catch (InterpreteurException lancee) {
+//                // Test OK
+//            }
+//        }
+//    }
+//    
+//    /**
+//     * Test de compareTo(Identificateur aComparer)
+//     */
+//    public static void testCompareTo() {
+//        final Identificateur REF_MIN = new Identificateur("$AAAAAAAAAAAAAAAAAAAAAAAA"); 
+//        final Identificateur REF_MAX = new Identificateur("zzzzzzzzzzzzzzzzzzzzzzzz");
+//        
+//        for(int noJeu = 0;  noJeu < FIXTURE.length; noJeu++) {
+//            assertTrue(FIXTURE[noJeu].compareTo(REF_MIN) >= 0);
+//            assertTrue(FIXTURE[noJeu].compareTo(REF_MAX) <= 0);
+//            assertTrue(FIXTURE[noJeu].compareTo(FIXTURE[noJeu]) == 0);
+//        }
+//    }
+//    
+//    /**
+//     * Tests unitaires de toString
+//     */
+//    public static void testToString() {
+//        final String[] CHAINES_VALIDES = {
+//                "b",
+//                "A",
+//                "zalpha",
+//                "Alpha",
+//                "Alpha5",
+//                "jeSuisUnTresLongIdentifi",
+//                "$b",
+//                "z",
+//                "$zalpha",
+//                "$Alpha",
+//                "$Alpha5",
+//                "$jeSuisUnTresLongIdentifi"
+//        };
+//
+//        for (int noJeu = 0 ; noJeu < CHAINES_VALIDES.length ; noJeu++) {
+//            assertEquivalence(CHAINES_VALIDES[noJeu],
+//                    FIXTURE[noJeu].toString());
+//        }
+//    }
+//}
 
-import interpreteurlir.InterpreteurException;
-import interpreteurlir.donnees.Identificateur;
-
-/**
- * Test de la classe donnees.Identificateur
- * @author Nicolas Caminade
- * @author Sylvan Courtiol
- * @author Pierre Debas
- * @author Heia Dexter
- * @author Lucas Vabre
- */
-public class TestIdentificateur {
-    
-    /** Jeu d'identificateurs correctement instanciés  */
-    public static final Identificateur[] FIXTURE = {
-        new Identificateur("b"),
-        new Identificateur("A"),
-        new Identificateur("zalpha"),
-        new Identificateur("Alpha"),
-        new Identificateur("Alpha5"),
-        new Identificateur("jeSuisUnTresLongIdentifi"),
-        new Identificateur("$b"),
-        new Identificateur("z"),
-        new Identificateur("$zalpha"),
-        new Identificateur("$Alpha"),
-        new Identificateur("$Alpha5"),
-        new Identificateur("$jeSuisUnTresLongIdentifi")
-            
-    };
-    
-    /**
-     * Test de Identificateur(String identificateur)
-     */
-    public static void testIdentificateurString() {
-        final String[] INVALIDE = {
-            null,
-            "",
-
-            // Fait au maximum 25 caractères
-            "$jeSuisUnTresLongIdentificateur", // 30 char
-            "$jeSuisUnTresLongIdentifica",
-
-            // Espaces
-            "id 3a",
-            "$id 3a",
-            " ",
-            "$ ",
-
-            // caractères d'échapements
-            "\t",
-            "\n",
-            "$\t",
-            "$\n",
-
-            // , cas particulier
-            "$"
-        };
-        
-        for(int noJeu = 0 ; noJeu < INVALIDE.length ; noJeu++) {
-            try {
-                new Identificateur(INVALIDE[noJeu]);
-                echec();
-            } catch (InterpreteurException lancee) {
-                // Test OK
-            }
-        }
-    }
-    
-    /**
-     * Test de compareTo(Identificateur aComparer)
-     */
-    public static void testCompareTo() {
-        final Identificateur REF_MIN = new Identificateur("$AAAAAAAAAAAAAAAAAAAAAAAA"); 
-        final Identificateur REF_MAX = new Identificateur("zzzzzzzzzzzzzzzzzzzzzzzz");
-        
-        for(int noJeu = 0;  noJeu < FIXTURE.length; noJeu++) {
-            assertTrue(FIXTURE[noJeu].compareTo(REF_MIN) >= 0);
-            assertTrue(FIXTURE[noJeu].compareTo(REF_MAX) <= 0);
-            assertTrue(FIXTURE[noJeu].compareTo(FIXTURE[noJeu]) == 0);
-        }
-    }
-    
-    /**
-     * Tests unitaires de toString
-     */
-    public static void testToString() {
-        final String[] CHAINES_VALIDES = {
-                "b",
-                "A",
-                "zalpha",
-                "Alpha",
-                "Alpha5",
-                "jeSuisUnTresLongIdentifi",
-                "$b",
-                "z",
-                "$zalpha",
-                "$Alpha",
-                "$Alpha5",
-                "$jeSuisUnTresLongIdentifi"
-        };
-
-        for (int noJeu = 0 ; noJeu < CHAINES_VALIDES.length ; noJeu++) {
-            assertEquivalence(CHAINES_VALIDES[noJeu],
-                    FIXTURE[noJeu].toString());
-        }
-    }
-}

src/interpreteurlir/donnees/tests/TestIdentificateurChaine.java

@@ -31,11 +31,11 @@ public class TestIdentificateurChaine {
     };
 
     /**
-     * Tests unitaires du constructeur IdentificateurEntier(String identificateur)
+     * Tests unitaires du constructeur 
+     * IdentificateurEntier(String identificateur)
      */
     public static void testIdentificateurChaineString() {
         final String[] INVALIDE = {
-                null,
                 "",
 
                 // Commence par une lettre
@@ -62,7 +62,8 @@ public class TestIdentificateurChaine {
                 "$",
                 "$1"
         };
-
+        System.out.println("\tExécution du test de "
+                           + "IdentificateurEntier(String identificateur)");
         for(int noJeu = 0; noJeu < INVALIDE.length ; noJeu++) {
             try {
                 new IdentificateurChaine(INVALIDE[noJeu]);
@@ -87,6 +88,7 @@ public class TestIdentificateurChaine {
                 "$jeSuisUnTresLongIdentifi"
         };
 
+        System.out.println("\tExécution du test de getNom()");
         for (int noJeu = 0 ; noJeu < NOM_VALIDES.length ; noJeu++) {
             assertEquivalence(NOM_VALIDES[noJeu], FIXTURE[noJeu].getNom());
         }

src/interpreteurlir/donnees/tests/TestVariable.java

@@ -63,36 +63,24 @@ public class TestVariable {
         new Chaine("\"titi\n\"")
     };
     
-//    /** Jeu d'entiers valides */
-//    private static final Entier[] VALEUR_ENTIER = {
-//        // TODO: jeu d'entiers valide
-//    };
-    
     /** Jeu de variables chaîne valides*/
     private static Variable[] fixtureChaine = new Variable[ID_CHAINE.length];   
     
-    /* Jeu de variables entières valides*/
-    //private static Variable[] fixtureEntier= new Variable[ID_ENTIER.length];
-    
     private static void fixtureReload() {
         for (int i = 0; i < ID_CHAINE.length; i++) {
             fixtureChaine[i] = new Variable(ID_CHAINE[i], VALEURS_CHAINE[i]); 
         }
-        
-        //TODO reload fixtureEntier
     }
     
     /** 
      * Test unitaire du constructeur Variable(Identificateur, Littéral)
      */
     public static void testVariableIdentificateurChaineLitteral() {
-        
+        System.out.println("\tExécution du test de "
+                           + "Variable(Identificateur, Littéral)");
         for (int noJeu = 0; noJeu < VALEURS_CHAINE.length; noJeu++) {
             try {
-                //new Variable(ID_CHAINE[noJeu], VALEURS_CHAINE[noJeu]); // bouchon
                 new Variable(ID_ENTIER[noJeu], VALEURS_CHAINE[noJeu]);
-                // TODO tester avec la classe Entier
-                // new Variable(ID_CHAINE[noJeu], VALEURS_ENTIER[noJeu]);
                 echec();
             } catch (InterpreteurException lancee) {
                 // test OK
@@ -106,32 +94,21 @@ public class TestVariable {
     public static void testGetIdentificateurChaine() {
         fixtureReload();
         
+        System.out.println("\tExécution du test de getIdentificateur()");
+        
         for (int i = 0; i < VALEURS_CHAINE.length; i++ ) {
             assertTrue(ID_CHAINE[i].compareTo(fixtureChaine[i]
                                               .getIdentificateur()) == 0);
         }
     }
     
-    /** 
-     * Test unitaire de getIdentificateur() d'une variable entière
-     */
-    public static void testGetIdentificateurEntier() {
-//        fixtureReload();
-//
-//        for (int i = 0; i < VALEURS_Entier.length; i++ ) {
-//            assertTrue(ID_ENTIER[i].compareTo(fixtureEntier[i]
-//                                              .getIdentificateur()) == 0);
-//        }
-        
-        echec();
-    }
-    
     /** 
      * Test unitaire de getValeur() d'une variable chaîne
      */
     public static void testGetValeurChaine() {
         fixtureReload();
         
+        System.out.println("\tExécution du test de getValeur()");
         for (int i = 0; i < VALEURS_CHAINE.length; i++ ) {
             assertTrue(VALEURS_CHAINE[i]
                            .compareTo(fixtureChaine[i].getValeur()) == 0);
@@ -153,6 +130,7 @@ public class TestVariable {
                 new Chaine("\"-5 + 962\"")
         };
         
+        System.out.println("\tExécution du test de setValeur()");
         for (int i = 0; i < NOUVELLE_CHAINE.length; i++) {
             fixtureChaine[i].setValeur(NOUVELLE_CHAINE[i]);
             assertTrue(NOUVELLE_CHAINE[i]
@@ -178,7 +156,7 @@ public class TestVariable {
                 "$MichelSardou = \"tata\t\"",
                 "$PhilippePoutou2022 = \"titi\n\""
         };
-                
+        System.out.println("\tExécution du test de toString()");        
         for (int noJeu = 0; noJeu < fixtureChaine.length; noJeu++ ) {
             assertEquivalence(fixtureChaine[noJeu].toString(), 
                               ATTENDUS[noJeu]);
@@ -199,12 +177,12 @@ public class TestVariable {
         = new Variable(new IdentificateurChaine("$z"),
                        new Chaine("\"Max\""));
 
+        System.out.println("\tExécution du test de compareTo");
         for(int noJeu = 0;  noJeu < fixtureChaine.length; noJeu++) {
             assertTrue(fixtureChaine[noJeu].compareTo(REF_MIN) > 0);
             assertTrue(fixtureChaine[noJeu].compareTo(REF_MAX) < 0);
             assertTrue(fixtureChaine[noJeu].compareTo(fixtureChaine[noJeu]) == 0);
         }
         
-        // TODO Faire le même test pour les variables contenant des entiers
     }
 }

src/interpreteurlir/expressions/Expression.java

@@ -19,7 +19,7 @@ import interpreteurlir.donnees.litteraux.Litteral;
  * @author Heïa Dexter
  * @author Lucas Vabre
  */
-public class Expression {
+public abstract class Expression {
     
     /** Index de l'operande gauche */
     protected static final int INDEX_OPERANDE_G = 0;
@@ -30,6 +30,12 @@ public class Expression {
     /** Index de de l'identificateur pour l'affectation */
     protected static final int INDEX_AFFECTATION = 2;
     
+    /** Index du premier symbole de l'opérateur */
+    protected static final int INDEX_OPERATEUR_G = 0;
+    
+    /** Index du second symbole de l'opérateur */
+    protected static final int INDEX_OPERATEUR_D = 1;
+
     /** Contexte global pour accéder aux données. */
     protected static Contexte contexteGlobal;
     
@@ -39,6 +45,12 @@ public class Expression {
     /** Littéraux opérandes de cette expression */
     protected Litteral[] litterauxOperandes;
     
+    /** 
+     * Opérateur de cette expression potentiellement 
+     * composé de plusieurs symboles 
+     */
+    protected char[] operateur;
+    
     /**
      * Initialise une expression par défaut avec les liens nécessaires à
      * son calcul.
@@ -48,6 +60,10 @@ public class Expression {
         final int NB_IDENTIFICATEUR = 3;
         final int NB_LITTERAL = 2;
         
+        operateur = new char[2];
+        operateur[INDEX_OPERATEUR_G] = '\u0000';
+        operateur[INDEX_OPERATEUR_D] = '\u0000';
+        
         identificateursOperandes = new Identificateur[NB_IDENTIFICATEUR];
         litterauxOperandes = new Litteral[NB_LITTERAL];
     }
@@ -77,20 +93,28 @@ public class Expression {
         Identificateur affect = identificateursOperandes[INDEX_AFFECTATION];
         resultat.append(affect == null ? "" : (affect.toString() + " = "));
         
-        Identificateur gaucheId = identificateursOperandes[INDEX_OPERANDE_G];
-        Litteral gaucheLitteral = litterauxOperandes[INDEX_OPERANDE_G];
-        resultat.append(gaucheId != null ? gaucheId.toString()
-                                         : gaucheLitteral.toString());
+        if (litterauxOperandes[INDEX_OPERANDE_G] != null) {
+            resultat.append(litterauxOperandes[INDEX_OPERANDE_G]);
+        } else {
+            resultat.append(identificateursOperandes[INDEX_OPERANDE_G]);
+        }
+        resultat.append(" ");
         
-        Identificateur droiteId = identificateursOperandes[INDEX_OPERANDE_D];
-        Litteral droiteLitteral = litterauxOperandes[INDEX_OPERANDE_D];
-        if (droiteId != null || droiteLitteral != null) {
-            resultat.append(" + ");
-            resultat.append(droiteId != null ? droiteId.toString()
-                                             : droiteLitteral.toString());
+        if (operateur[INDEX_OPERATEUR_G] != '\u0000') {
+            resultat.append(operateur[INDEX_OPERATEUR_G]);
+        }
+        if (operateur[INDEX_OPERATEUR_D] != '\u0000') {
+            resultat.append(operateur[INDEX_OPERATEUR_D]);
         }
         
-        return resultat.toString();
+        resultat.append(" ");
+        if (litterauxOperandes[INDEX_OPERANDE_D] != null) {
+            resultat.append(litterauxOperandes[INDEX_OPERANDE_D]);
+        } else if (identificateursOperandes[INDEX_OPERANDE_D] != null) {
+            resultat.append(identificateursOperandes[INDEX_OPERANDE_D]);
+        }       
+        
+        return resultat.toString().trim();
     }
 
     /**
@@ -129,4 +153,26 @@ public class Expression {
             return new ExpressionEntier(aTraiter);
         }
     }
+    
+    /**
+     * Détermine l'index du caractère en dehors des constantes littérales
+     * @param aTraiter chaîne à traiter
+     * @param caractere opérateur à chercher hors guillemet
+     * @return index dans à traiter du plus sinon -1 si aucun plus
+     */
+    public static int detecterCaractere(String aTraiter, char caractere) {
+        char[] aTester = aTraiter.toCharArray();
+        int indexPlus;
+        int nbGuillemet = 0;
+        for (indexPlus = 0 ; 
+             indexPlus < aTester.length 
+             && (aTester[indexPlus] != caractere || nbGuillemet % 2 != 0) ;
+             indexPlus++) {
+            
+            if (aTester[indexPlus] == '"') {
+                nbGuillemet++;
+            } 
+        }
+        return indexPlus >= aTester.length ? -1 : indexPlus;
+    }
 }

src/interpreteurlir/expressions/ExpressionBooleenne.java

@@ -0,0 +1,287 @@
+/**
+ * ExpressionBooleenne.java                              21 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.expressions;
+
+import static interpreteurlir.donnees.IdentificateurChaine
+                                     .isIdentificateurChaine;
+import static interpreteurlir.donnees.IdentificateurEntier
+                                     .isIdentificateurEntier;
+import static interpreteurlir.donnees.litteraux.Entier.isEntier;
+import static interpreteurlir.donnees.litteraux.Chaine.isChaine;
+
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.donnees.IdentificateurChaine;
+import interpreteurlir.donnees.IdentificateurEntier;
+import interpreteurlir.donnees.litteraux.*;
+
+/** 
+ * Expression de type Booleen qui peut être évaluée.
+ * <p>
+ * Syntaxe d'une expression logique : opérande1 oprel opérande2
+ * <p>
+ * Les expressions logiques concerneront donc toujours deux opérandes
+ * séparés par un opérateur relationnel (notation infixe). Un opérande
+ * est soit une constante, soit un identificateur.
+ * <p>
+ * L'’opérateur relationnel oprel est un symbole parmi : {@code = <> < <= > >=}
+ * 
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class ExpressionBooleenne extends Expression {
+    
+    /** Liste des opérateurs relationnels utilisés */
+    private static char[] OPERATEURS = { '<', '>', '=' };
+    
+    private static final String ERREUR_ARGUMENT = "une expression ne peut être "
+                                                  + "vide";
+    private static final String ERREUR_SYNTAXE = 
+                                     "usage <opérande1> <oprel> <opérande2> \n"
+                                   + "avec oprel comme opérateur relationnel "
+                                   + "un des symboles suivants : <> < <= > >="
+                                   + "et comme opérandes des constantes, "
+                                   + "ou alors des identificateurs";
+    private static final String ERREUR_TYPE = "opérande invalide "
+                                              + "ou type incompatible";
+    private static final String ERREUR_OPERATEUR = "opérateur inconnu";
+    
+            
+    /** 
+     * Initialise une expression de type Booleen avec les liens 
+     * nécessaires à son calcul.
+     * 
+     * @param texteExpression l'expression booléenne lue sous forme 
+     *                        de chaîne
+     * @throws InterpreteurException si l'expression est vide ou les
+     *                               types des opérandes sont incompatibles
+     *                               ou si l'opérande droit est manquant
+     */
+    public ExpressionBooleenne(String texteExpression) {
+        super();
+        
+        String gauche;
+        String droite;
+        String aTraiter;
+        
+        if (texteExpression == null || texteExpression.isBlank()) {
+            throw new InterpreteurException(ERREUR_ARGUMENT);
+        }
+        
+        aTraiter = texteExpression.trim();
+        
+        int[] indexOperateurs = affecterOperateur(aTraiter, 
+                                                  detecterOperateurs(aTraiter));
+        
+        if (indexOperateurs[INDEX_OPERATEUR_D] > aTraiter.length() - 2
+                || indexOperateurs[INDEX_OPERATEUR_G] <= 0) {
+            throw new InterpreteurException(aTraiter + ERREUR_SYNTAXE);
+        }
+        
+        gauche = aTraiter.substring(0, indexOperateurs[INDEX_OPERATEUR_G])
+                         .trim();
+        droite = aTraiter.substring(indexOperateurs[INDEX_OPERATEUR_D] + 1)
+                         .trim();
+        
+        if (!isMemeType(gauche, droite)) {
+            throw new InterpreteurException(ERREUR_TYPE);
+        }
+        
+        initialiserOperande(gauche, INDEX_OPERANDE_G);
+        initialiserOperande(droite, INDEX_OPERANDE_D);
+    }
+
+    /**
+     * Affecte les symboles de l'opérateur à partir des index de indexOperateur
+     * correspondant à des caractères dans aTraiter.
+     * @param aTraiter chaîne contenant les opérateurs
+     * @param indexOperateurs index des symboles de l'opérateur.
+     * @return tableau d'index avec l'index de début de l'opérateur en indice 0
+     *         et l'index de la fin de l'opérateur en indice 1.
+     *         Les index peuvent être égaux.
+     * @throws InterpreteurException si les symboles de l'opérateur ne
+     *                               se suivent pas dans aTraiter
+     *                               
+     */
+    private int[] affecterOperateur(String aTraiter, int[] indexOperateurs) {
+        operateur[INDEX_OPERATEUR_G] = indexOperateurs[INDEX_OPERATEUR_G] <= 0 
+                ? '\u0000'
+                : aTraiter.charAt(indexOperateurs[INDEX_OPERATEUR_G]);
+        operateur[INDEX_OPERATEUR_D]   = indexOperateurs[INDEX_OPERATEUR_D] <= 0 
+                ? '\u0000'
+                : aTraiter.charAt(indexOperateurs[INDEX_OPERATEUR_D]);
+        
+        if (indexOperateurs[INDEX_OPERATEUR_G] <= 0) {
+            indexOperateurs[INDEX_OPERATEUR_G] = 
+                                             indexOperateurs[INDEX_OPERATEUR_D];
+            
+        } else if (indexOperateurs[INDEX_OPERATEUR_D] <= 0) {
+            indexOperateurs[INDEX_OPERATEUR_D] = 
+                                             indexOperateurs[INDEX_OPERATEUR_G];
+        }
+        
+        if (indexOperateurs[INDEX_OPERATEUR_D] 
+                - indexOperateurs[INDEX_OPERATEUR_G] > 1
+                || !isOperateurValide()) {
+            throw new InterpreteurException(ERREUR_OPERATEUR);
+        }
+        return indexOperateurs;
+    }
+
+    /**
+     * Prédicat de validité de concordance des symboles 
+     * de l'opérateur à faire un opérateur valide
+     * @return true si opérateur formé par les symboles est valide, false sinon
+     */
+    private boolean isOperateurValide() {
+        
+        final String[] OPERATEUR_VALIDE = {
+            "<", ">", "<=", ">=", "=", "<>"        
+        };
+        
+        String aTester = "";
+        if (operateur[INDEX_OPERATEUR_G] != '\u0000') {
+            aTester = aTester + operateur[INDEX_OPERATEUR_G];
+        }
+        if (operateur[INDEX_OPERATEUR_D] != '\u0000') {
+            aTester = aTester + operateur[INDEX_OPERATEUR_D];
+        }
+        
+        int index;
+        for (index = 0 ; 
+             index < OPERATEUR_VALIDE.length 
+             && !OPERATEUR_VALIDE[index].equals(aTester);
+             index++)
+            ; /* empty body */
+        return index < OPERATEUR_VALIDE.length;
+    }
+
+    /**
+     * Prédicat de validité de compatibilité 
+     * entre les opérandes gauche et droite
+     * @param gauche opérande gauche
+     * @param droit opérande droit
+     * @return true si deux opérandes sont de même type
+     *         sinon false
+     */
+    private static boolean isMemeType(String gauche, String droit) {
+        return (     (isIdentificateurEntier(gauche) || isEntier(gauche))
+                  && (isIdentificateurEntier(droit)  || isEntier(droit)))
+               || 
+               (     (isIdentificateurChaine(gauche) || isChaine(gauche)))
+                  && (isIdentificateurChaine(droit)  || isChaine(droit));
+
+    }
+    
+
+    /** 
+     * Détecte les opérateurs d'une expression logique
+     * @param aTraiter chaine dont on cherche les opérateurs
+     * @return les indexes de début et de fin du premier et unique
+     *         opérateur trouvé
+     * @throws InterpreteurException s'il l'opérateur est invalide
+     *                               ou inexistant
+     */
+    private static int[] detecterOperateurs(String aTraiter) {
+        int[] index = new int[2];
+        char charCourant;
+        index[INDEX_OPERATEUR_G] = -1;
+        index[INDEX_OPERATEUR_D] = -1;
+        int nbGuillemet = 0;
+
+        for (int i = 0 ; i < aTraiter.length() - 1 ; i++) {
+            charCourant = aTraiter.charAt(i);
+            
+            if (charCourant == '"') {
+                nbGuillemet++;
+            }
+            
+            if (index[INDEX_OPERATEUR_G] < 0 && (nbGuillemet & 1) == 0 
+                    && (   charCourant == OPERATEURS[0] 
+                        || charCourant == OPERATEURS[1])) {
+                index[INDEX_OPERATEUR_G] = i;
+            } else if ((nbGuillemet & 1) == 0 
+                       && (charCourant == OPERATEURS[1] 
+                           || charCourant == OPERATEURS[2])) {
+                index[INDEX_OPERATEUR_D] = i;
+            }
+        }
+        
+        if (index[INDEX_OPERATEUR_G] == index[INDEX_OPERATEUR_D]) {
+            throw new InterpreteurException(ERREUR_OPERATEUR);
+        }
+        
+        return index;
+    }
+
+    /**
+     * Initialise l'opérande à sa place dans l'Expression.
+     * @param operande 
+     * @param index
+     * @throws IllegalArgumentException si index invalide
+     */
+    private void initialiserOperande(String operande, int index) {
+        if (INDEX_OPERANDE_G != index && INDEX_OPERANDE_D != index) {
+            throw new IllegalArgumentException("index invalide");
+        }
+        
+        if (isIdentificateurEntier(operande)) {
+            identificateursOperandes[index] = 
+                                             new IdentificateurEntier(operande);
+        } else if (isIdentificateurChaine(operande)) {
+            identificateursOperandes[index] = 
+                                             new IdentificateurChaine(operande);
+        } else if (isChaine(operande)) {
+            litterauxOperandes[index] = new Chaine(operande);
+        } else {
+            litterauxOperandes[index] = new Entier(operande);
+        }
+    }
+    
+
+    /* non javadoc
+     * @see interpreteurlir.expressions.Expression#calculer()
+     */
+    @Override
+    public Booleen calculer() {
+        Litteral gauche = litterauxOperandes[INDEX_OPERANDE_G] != null 
+                          ? litterauxOperandes[INDEX_OPERANDE_G] 
+                          : contexteGlobal.lireValeurVariable(
+                                    identificateursOperandes[INDEX_OPERANDE_G]);
+        Litteral droite = litterauxOperandes[INDEX_OPERANDE_D] != null 
+                          ? litterauxOperandes[INDEX_OPERANDE_D] 
+                          : contexteGlobal.lireValeurVariable(
+                                    identificateursOperandes[INDEX_OPERANDE_D]);
+        
+        return new Booleen(calculAvecOperateur(gauche, droite));
+    }
+
+    /**
+     * Calcule la valeur de l'expression selon l'opérateur 
+     * à partir de l'opérande gauche et droite
+     * Les opérande doivent être du même type.
+     * @param gauche opérande gauche
+     * @param droite opérande droite
+     * @return true si expression true sinon false
+     */
+    private boolean calculAvecOperateur(Litteral gauche, Litteral droite) {
+        boolean resultat = false;
+        if (operateur[INDEX_OPERATEUR_G] == OPERATEURS[0]) {
+            resultat = gauche.compareTo(droite) < 0;
+        } else if (operateur[INDEX_OPERATEUR_G] == OPERATEURS[1]) {
+            resultat = gauche.compareTo(droite) > 0;
+        }
+        
+        if (operateur[INDEX_OPERATEUR_D] == OPERATEURS[1]) {
+            resultat = resultat || gauche.compareTo(droite) > 0;
+        } else if (operateur[INDEX_OPERATEUR_D] == OPERATEURS[2]) {
+            resultat = resultat || gauche.compareTo(droite) == 0;
+        }        
+        
+        return resultat;
+    }
+}

src/interpreteurlir/expressions/ExpressionChaine.java

@@ -19,8 +19,11 @@ import interpreteurlir.donnees.litteraux.Chaine;
  */
 public class ExpressionChaine extends Expression {
 
+    /** Opérateur possible pour ce type d'expression */
+    private static final char OPERATEUR = '+';
+    
     /**
-     * Initalise une expression de type Chaine 
+     * Initialise une expression de type Chaine 
      * avec les liens nécessaires à son calcul.
      * @param texteExpression texte suivant la syntaxe d'une expression
      * @throws InterpreteurException si texteExpression n'est pas valide
@@ -50,39 +53,18 @@ public class ExpressionChaine extends Expression {
         }
         
         /* Traitement du nombre d'opérande */
-        int indexPlus = indexOperateur(aTraiter, '+');
+        int indexPlus = detecterCaractere(aTraiter, '+');
         gauche = aTraiter;
         if (indexPlus > -1) {
             gauche = aTraiter.substring(0, indexPlus);
             droite = aTraiter.substring(indexPlus + 1, aTraiter.length());
+            operateur[INDEX_OPERANDE_G] = OPERATEUR;
             initialiserOperande(droite, INDEX_OPERANDE_D);
         }
         
         initialiserOperande(gauche, INDEX_OPERANDE_G);
     }
 
-    /**
-     * Détermine l'index de l'opérateur en dehors des constantes littérales
-     * @param aTraiter chaîne à traiter
-     * @param operateur opérateur à chercher hors guillemet
-     * @return index dans à traiter du plus sinon -1 si aucun plus
-     */
-    public static int indexOperateur(String aTraiter, char operateur) {
-        char[] aTester = aTraiter.toCharArray();
-        int indexPlus;
-        int nbGuillemet = 0;
-        for (indexPlus = 0 ; 
-             indexPlus < aTester.length 
-             && (aTester[indexPlus] != operateur || nbGuillemet % 2 != 0) ;
-             indexPlus++) {
-            
-            if (aTester[indexPlus] == '"') {
-                nbGuillemet++;
-            } 
-        }
-        return indexPlus >= aTester.length ? -1 : indexPlus;
-    }
-
     /**
      * Initialise l'opérande à sa place dans l'expression.
      * @param operande représentation texte de l'opérande
@@ -95,7 +77,7 @@ public class ExpressionChaine extends Expression {
             throw new IllegalArgumentException("index invalide");
         }
         
-        if (operandeEstLitteral(operande)) {
+        if (Chaine.isChaine(operande)) {
             litterauxOperandes[index] = new Chaine(operande);
         } else {
             identificateursOperandes[index] = 
@@ -103,14 +85,6 @@ public class ExpressionChaine extends Expression {
         }
     }
 
-    /**
-     * Détermine le genre de l'opérande (Chaine ou IdentificateurChaine).
-     * @param operande représentation texte de l'opérande
-     * @return true si operande est du genre Litteral sinon false
-     */
-    private static boolean operandeEstLitteral(String operande) {
-        return operande.trim().startsWith("\"");
-    }
 
     /* non javadoc
      * @see interpreteurlir.expressions.Expression#calculer()

src/interpreteurlir/expressions/ExpressionEntier.java

@@ -7,11 +7,8 @@ package interpreteurlir.expressions;
 import interpreteurlir.ExecutionException;
 import interpreteurlir.InterpreteurException;
 import interpreteurlir.donnees.Identificateur;
-import interpreteurlir.donnees.IdentificateurChaine;
 import interpreteurlir.donnees.IdentificateurEntier;
-import interpreteurlir.donnees.litteraux.Chaine;
 import interpreteurlir.donnees.litteraux.Entier;
-import interpreteurlir.donnees.litteraux.Litteral;
 
 /**
  * Expression de type Entier qui peut être calculer.
@@ -32,12 +29,11 @@ public class ExpressionEntier extends Expression {
     
     /** Erreur opérande attendue */
     private static final String OPERANDE_D_MANQUANT = 
-            " : opérande droit attendu";
+            " attend un opérande droit";
     
-    private char operateur;
 
     /**
-     * Initalise une expression de type Entier avec les liens nécessaires à son
+     * Initialise une expression de type Entier avec les liens nécessaires à son
      * calcule.
      * @param texteExpression texte suivant la syntaxe d'une expression
      * @throws InterpreteurException si texteExpression n'est pas valide
@@ -49,8 +45,9 @@ public class ExpressionEntier extends Expression {
         String droite;
         String aTraiter;
         
-        if (texteExpression == null || texteExpression.isBlank())
+        if (texteExpression == null || texteExpression.isBlank()) {
             throw new InterpreteurException(ERREUR_VIDE);
+        }
         
         aTraiter = texteExpression.trim();
         
@@ -58,7 +55,8 @@ public class ExpressionEntier extends Expression {
         int indexEgal = aTraiter.indexOf('=');
         if (indexEgal > 0) {
             identificateursOperandes[INDEX_AFFECTATION] = 
-                new IdentificateurEntier(aTraiter.substring(0, indexEgal).trim());
+                    new IdentificateurEntier(aTraiter.substring(0, indexEgal)
+                                                     .trim());
         
             aTraiter = aTraiter.substring(indexEgal + 1).trim();
         }
@@ -67,11 +65,12 @@ public class ExpressionEntier extends Expression {
         int indexOperateur = detecterOperateur(aTraiter);
         gauche = aTraiter.trim();
         if (indexOperateur > 0) {
-            operateur = aTraiter.charAt(indexOperateur);
+            operateur[INDEX_OPERATEUR_G] = aTraiter.charAt(indexOperateur);
             gauche = aTraiter.substring(0, indexOperateur).trim();
             
-            if (aTraiter.length() - 1 <= indexOperateur)
+            if (aTraiter.length() - 1 <= indexOperateur) {
                 throw new ExecutionException(aTraiter + OPERANDE_D_MANQUANT);
+            }
             
             droite = aTraiter.substring(indexOperateur + 1).trim();
             initialiserOperande(droite, INDEX_OPERANDE_D);
@@ -88,25 +87,27 @@ public class ExpressionEntier extends Expression {
      */
     private static int detecterOperateur(String expression) {
         for (int i = 1 ; i < expression.length() ; i++) {
-            for (char operateur : OPERATEURS)
-                if (operateur == expression.charAt(i))
+            for (char operateur : OPERATEURS) {
+                if (operateur == expression.charAt(i)) {
                     return i;
                 }
+            }
+        }
         
         return -1;
     }
 
     /**
      * Initialise l'opérande à sa place dans l'expression.
-     * @param droite
-     * @param indexOperandeD
+     * @param operande opérande à initialiser
+     * @param index de l'opérande
      */
     private void initialiserOperande(String operande, int index) {
         if (INDEX_OPERANDE_G != index && INDEX_OPERANDE_D != index) {
             throw new IllegalArgumentException("index invalide");
         }
         
-        if (operandeEstLitteral(operande)) {
+        if (Entier.isEntier(operande)) {
             litterauxOperandes[index] = new Entier(operande);
         } else {
             identificateursOperandes[index] = 
@@ -115,17 +116,6 @@ public class ExpressionEntier extends Expression {
         
     }
 
-    /**
-     * Détermine si l'opérande est un littéral de type entier
-     * @param operande à tester
-     * @return true si l'operande commence par +, - ou un chiffre,
-     *         false dans le cas contraire.
-     */
-    private static boolean operandeEstLitteral(String operande) {
-        char aTester = operande.charAt(0);
-        return Character.isDigit(aTester) || aTester == '-' || aTester == '+';
-    }
-
     /* non javadoc
      * @see interpreteurlir.expressions.Expression#calculer()
      */
@@ -154,7 +144,7 @@ public class ExpressionEntier extends Expression {
         /* Calcul de la valeur */
         valeur = operandeD == null 
                  ? operandeG 
-                 : switch (operateur) {
+                 : switch (operateur[INDEX_OPERATEUR_G]) {
                    case '+' -> Entier.somme(operandeG, operandeD);
                    case '-' -> Entier.soustrait(operandeG, operandeD);
                    case '*' -> Entier.multiplie(operandeG, operandeD);
@@ -172,30 +162,4 @@ public class ExpressionEntier extends Expression {
         return valeur;
     }
 
-    /*
-     * Non - javadoc
-     * @see java.lang.Object#toString()
-     */
-    @Override
-    public String toString() {
-        StringBuilder resultat = new StringBuilder("");
-        
-        Identificateur affect = identificateursOperandes[INDEX_AFFECTATION];
-        resultat.append(affect == null ? "" : (affect.toString() + " = "));
-        
-        Identificateur gaucheId = identificateursOperandes[INDEX_OPERANDE_G];
-        Litteral gaucheLitteral = litterauxOperandes[INDEX_OPERANDE_G];
-        resultat.append(gaucheId != null ? gaucheId.toString()
-                                         : gaucheLitteral.toString());
-        
-        Identificateur droiteId = identificateursOperandes[INDEX_OPERANDE_D];
-        Litteral droiteLitteral = litterauxOperandes[INDEX_OPERANDE_D];
-        if (droiteId != null || droiteLitteral != null) {
-            resultat.append(" " + operateur + " ");
-            resultat.append(droiteId != null ? droiteId.toString()
-                                             : droiteLitteral.toString());
-        }
-        
-        return resultat.toString();
-    }
 }

src/interpreteurlir/expressions/tests/TestExpression.java

@@ -21,23 +21,6 @@ import interpreteurlir.Contexte;
  */
 public class TestExpression {
     
-    /** Jeu d'essai d'expression typée */
-    private Expression[] fixture = {
-        new ExpressionChaine("$chaine = \"texte\""),  
-        new ExpressionChaine("$chaine=\"tata\""),
-        new ExpressionChaine("   $tata  \t  "),
-        new ExpressionChaine("\"une chaine de texte\""),
-        new ExpressionChaine("$chaine= \"toto\"+\"titi\""),
-        new ExpressionChaine("$chaine= $toto +\"titi\""),
-        new ExpressionChaine("$chaine= \"toto\"+ $titi"),
-        new ExpressionChaine("$chaine=$toto +$titi"),
-        new ExpressionChaine("   \"toto\"+\"titi\""),
-        new ExpressionChaine("$toto +\"titi\""),
-        new ExpressionChaine("\"toto\"+ $titi"),
-        new ExpressionChaine("$toto +    $titi"), 
-        // TODO expression entière
-    };
-    
     /**
      * Tests unitaires de {@link Expression#referencerContexte(Contexte)}
      */
@@ -58,32 +41,6 @@ public class TestExpression {
         }
     }
     
-    /**
-     * Tests unitaires de {@link Expression#toString()}
-     */
-    public void testToString() {
-        final String[] chaineAttendue = {
-            "$chaine = \"texte\"",  
-            "$chaine = \"tata\"",
-            "$tata",
-            "\"une chaine de texte\"",
-            "$chaine = \"toto\" + \"titi\"",
-            "$chaine = $toto + \"titi\"",
-            "$chaine = \"toto\" + $titi",
-            "$chaine = $toto + $titi",
-            "\"toto\" + \"titi\"",
-            "$toto + \"titi\"",
-            "\"toto\" + $titi",
-            "$toto + $titi"       
-        };
-        
-        System.out.println("\tExécution du test de Expression#toString()");
-        for (int numTest = 0 ; numTest < chaineAttendue.length ; numTest++) {
-            assertEquivalence(chaineAttendue[numTest], 
-                              fixture[numTest].toString());
-        }
-    }
-    
     /**
      * Tests unitaires de {@link Expression#determinerTypeExpression(String)}
      */

src/interpreteurlir/expressions/tests/TestExpressionBooleenne.java

@@ -0,0 +1,467 @@
+/**
+ * TestExpressionBooleenne.java                              21 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.expressions.tests;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.donnees.IdentificateurChaine;
+import interpreteurlir.donnees.IdentificateurEntier;
+import interpreteurlir.donnees.litteraux.Chaine;
+import interpreteurlir.donnees.litteraux.Entier;
+import interpreteurlir.expressions.Expression;
+import interpreteurlir.expressions.ExpressionBooleenne;
+import static info1.outils.glg.Assertions.*;
+
+/** 
+ * Tests unitaires des méthodes de la classe ExpressionBooleenne
+ * 
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class TestExpressionBooleenne {
+    
+    private final ExpressionBooleenne[] FIXTURE_LITTERALE = {
+        /* Expression logique sur des Entiers AVEC ESPACES */
+        new ExpressionBooleenne("1 = 1"), // true
+        new ExpressionBooleenne("1 = 2"), // false
+        new ExpressionBooleenne("1 < 2"),
+        new ExpressionBooleenne("1 < 1"),
+        new ExpressionBooleenne("1 <> 2"),
+        new ExpressionBooleenne("1 <> 1"),
+        new ExpressionBooleenne("1 <= 1"),
+        new ExpressionBooleenne("1 <= 5"),
+        new ExpressionBooleenne("1 > -3"),
+        new ExpressionBooleenne("1 > 56"),
+        new ExpressionBooleenne("1 >= 1"),
+        new ExpressionBooleenne("1 >= 45"),
+        /* Expression logique sur des Entiers SANS ESPACES */
+        new ExpressionBooleenne("1=1"),
+        new ExpressionBooleenne("1=2"),
+        new ExpressionBooleenne("1<2"),
+        new ExpressionBooleenne("1<1"),
+        new ExpressionBooleenne("1<>2"),
+        new ExpressionBooleenne("1<>1"),
+        new ExpressionBooleenne("1<=1"),
+        new ExpressionBooleenne("1<=5"),
+        new ExpressionBooleenne("1>-3"),
+        new ExpressionBooleenne("1>56"),
+        new ExpressionBooleenne("1>=1"),
+        new ExpressionBooleenne("1>=45"),
+        /* Expression logique sur des Entiers MOITIE ESPACES */
+        new ExpressionBooleenne("    1=1"),
+        new ExpressionBooleenne("1=2    "),
+        new ExpressionBooleenne("1 <2"),
+        new ExpressionBooleenne("1< 1"),
+        new ExpressionBooleenne("1  <>2"),
+        new ExpressionBooleenne("1<>   1"),
+        new ExpressionBooleenne("   1<=1   "),
+        new ExpressionBooleenne("1   <=   5"),
+        new ExpressionBooleenne("    1   >  -3   "),
+        new ExpressionBooleenne("1>56\t"),
+        new ExpressionBooleenne("   1    >=  1    "),
+        new ExpressionBooleenne("    1       >=    45   "),
+        
+        /* Expression logique sur des Chaines AVEC ESPACES */
+        new ExpressionBooleenne("\"TATA\" = \"TATA\""),
+        new ExpressionBooleenne("\"TATA\" = \"TITI\""),
+        new ExpressionBooleenne("\"TATA\" < \"TITI\""),
+        new ExpressionBooleenne("\"TOTO\" < \"TITI\""),
+        new ExpressionBooleenne("\"TOTO\" <> \"TATA\""),
+        new ExpressionBooleenne("\"TATA\" <> \"TATA\""),
+        new ExpressionBooleenne("\"TATA\" <= \"TATA\""),
+        new ExpressionBooleenne("\"TITI\" <= \"TATA\""),
+        new ExpressionBooleenne("\"TATA\" > \"FOO BAR\""),
+        new ExpressionBooleenne("\"FOO BAR\" > \"TATA\""),
+        new ExpressionBooleenne("\"TATA\" >= \"TATA\""),
+        new ExpressionBooleenne("\"FOO BAR\" >= \"TATA\""),
+        /* Expression logique sur des Chaines SANS ESPACES */
+        new ExpressionBooleenne("\"TATA\"=\"TATA\""),
+        new ExpressionBooleenne("\"TATA\"=\"TITI\""),
+        new ExpressionBooleenne("\"TATA\"<\"TITI\""),
+        new ExpressionBooleenne("\"TOTO\"<\"TITI\""),
+        new ExpressionBooleenne("\"TOTO\"<>\"TATA\""),
+        new ExpressionBooleenne("\"TATA\"<>\"TATA\""),
+        new ExpressionBooleenne("\"TATA\"<=\"TATA\""),
+        new ExpressionBooleenne("\"TITI\"<=\"TATA\""),
+        new ExpressionBooleenne("\"TATA\">\"FOO BAR\""),
+        new ExpressionBooleenne("\"FOO BAR\">\"TATA\""),
+        new ExpressionBooleenne("\"TATA\">=\"TATA\""),
+        new ExpressionBooleenne("\"FOO BAR\">=\"TATA\""),
+        /* Expression logique sur des Chaines MOITIE ESPACES */
+        new ExpressionBooleenne("        \"TATA\" = \"TATA\""),
+        new ExpressionBooleenne("\"TATA\"           = \"TITI\""),
+        new ExpressionBooleenne("\"TATA\" <          \"TITI\""),
+        new ExpressionBooleenne("\"TOTO\" < \"TITI\"       "),
+        new ExpressionBooleenne("     \"TOTO\"<> \"TATA\"       "),
+        new ExpressionBooleenne("\"TATA\"     <>     \"TATA\"     "),
+        new ExpressionBooleenne("        \"TATA\" <=\"TATA\""),
+        new ExpressionBooleenne("\"TITI\" <=       \"TATA\""),
+        new ExpressionBooleenne("      \"TATA\" > \"FOO BAR\""),
+        new ExpressionBooleenne("    \"FOO BAR    \"       > \"TATA\""),
+        new ExpressionBooleenne("\"TATA\"        >=         \"TATA\""),
+        new ExpressionBooleenne("            \"FOO BAR\" >=      \"TATA\""),
+        /* Expression logique sur des Chaines AVEC OPERATEURS */
+        new ExpressionBooleenne("\"FOO BAR\"<>\"TATA=TOTO\""),
+        new ExpressionBooleenne("\"FOO BAR=FLEMME\">\"TOTO\""),
+        new ExpressionBooleenne("\"FOO BAR > FLEMME\"=\"TOTO\""),
+        new ExpressionBooleenne("\"FOO BAR<>FLEMME\">\"TOTO\""),
+        
+    };
+        
+    private final ExpressionBooleenne[] FIXTURE_ID = {
+        /* Expression logique sur des IdEntier et Entiers */
+        new ExpressionBooleenne("marcel <= 10"), // true
+        new ExpressionBooleenne("marcel > j34n"), // false
+        new ExpressionBooleenne("2 = pi3rr3"),
+        new ExpressionBooleenne("j34n = pi3rr3"),
+        /* Expression logique sur des IdChaine et Chaines */
+        new ExpressionBooleenne("$sanchis < $barrios"),
+        new ExpressionBooleenne("$servieres > \"Windows\""),
+        new ExpressionBooleenne("$barrios <> $servieres"),
+        new ExpressionBooleenne("\"coucou\" = $barrios"),
+    };
+
+    /** 
+     * Tests unitaire de {@link ExpressionBooleenne#ExpressionBooleenne(String)}
+     */
+    public void testExpressionBooleenne() {
+        
+        final String[] INVALIDES = {
+            /* Pas d'opérateur */
+            "",
+            "2 5",
+            "\"John Doe\"",
+            "\"Foo bar\" $serpillere",
+            "entier -20",
+            /* Opérateurs invalides */
+            "-89 + 67",
+            "-8979 % 7",
+            "35 * 12",
+            "89 / 12",
+            "65 - 74",
+            "\"Foo bar\" + $serpillere",
+            "ab >> cd",
+            /* Expressions logiques avec opérateurs invalides */
+            "78 < =  45",
+            "entier > = 56",
+            "\"Foo bar\" < > $serpillere",
+            "$coucou >< $dollarchaine",
+            "78 => 45",
+            "32 =< 61",
+            "32 == 61",
+            /* Plus de 2 opérandes et 1 opérateur */
+            "65 <> 45 = 45",
+            "entier > 85 && 45 = 12",
+            "entier <= 85 || 45 <> 12",
+            /* Caractères entre les opérandes et l'opérateur */
+            "\"Foo bar\"  . > $serpillere",
+            "\"Foo bar\"  < _ $serpillere",
+            "\"Foo bar\" + $balai > serpillere",
+            /* opérande manquant */
+            ">= entier",
+            "entier =",
+            "<>",
+            /* Incompatibilité entre types d'opérandes */
+            "\"Foo bar\" > serpillere",
+            "serpillere <> \"Foo bar\"",
+            "15 > $coucou",
+            "\"coucou\" <> 45",
+            "$coucou = entier"
+        };
+
+        System.out.println("\tExécution du test de ExpressionBooleenne()");
+        
+        for (String aTester : INVALIDES) {
+            try {
+                new ExpressionBooleenne(aTester);
+                echec();
+            } catch (InterpreteurException lancee) {
+                // Test OK
+            }
+        }
+        
+        try {
+            /* Expression logique sur des Entiers AVEC ESPACES */
+            new ExpressionBooleenne("1 = 1"); // true
+            new ExpressionBooleenne("1 = 2"); // false
+            new ExpressionBooleenne("1 < 2");
+            new ExpressionBooleenne("1 < 1");
+            new ExpressionBooleenne("1 <> 2");
+            new ExpressionBooleenne("1 <> 1");
+            new ExpressionBooleenne("1 <= 1");
+            new ExpressionBooleenne("1 <= 5");
+            new ExpressionBooleenne("1 > -3");
+            new ExpressionBooleenne("1 > 56");
+            new ExpressionBooleenne("1 >= 1");
+            new ExpressionBooleenne("1 >= 45");
+            /* Expression logique sur des Entiers SANS ESPACES */
+            new ExpressionBooleenne("1=1");
+            new ExpressionBooleenne("1=2");
+            new ExpressionBooleenne("1<2");
+            new ExpressionBooleenne("1<1");
+            new ExpressionBooleenne("1<>2");
+            new ExpressionBooleenne("1<>1");
+            new ExpressionBooleenne("1<=1");
+            new ExpressionBooleenne("1<=5");
+            new ExpressionBooleenne("1>-3");
+            new ExpressionBooleenne("1>56");
+            new ExpressionBooleenne("1>=1");
+            new ExpressionBooleenne("1>=45");
+            /* Expression logique sur des Entiers MOITIE ESPACES */
+            new ExpressionBooleenne("    1=1");
+            new ExpressionBooleenne("1=2    ");
+            new ExpressionBooleenne("1 <2");
+            new ExpressionBooleenne("1< 1");
+            new ExpressionBooleenne("1  <>2");
+            new ExpressionBooleenne("1<>   1");
+            new ExpressionBooleenne("   1<=1   ");
+            new ExpressionBooleenne("1   <=   5");
+            new ExpressionBooleenne("    1   >  -3   ");
+            new ExpressionBooleenne("1>56\t");
+            new ExpressionBooleenne("   1    >=  1    ");
+            new ExpressionBooleenne("    1       >=    45   ");
+            
+            /* Expression logique sur des Chaines AVEC ESPACES */
+            new ExpressionBooleenne("\"TATA\" = \"TATA\"");
+            new ExpressionBooleenne("\"TATA\" = \"TITI\"");
+            new ExpressionBooleenne("\"TATA\" < \"TITI\"");
+            new ExpressionBooleenne("\"TOTO\" < \"TITI\"");
+            new ExpressionBooleenne("\"TOTO\" <> \"TATA\"");
+            new ExpressionBooleenne("\"TATA\" <> \"TATA\"");
+            new ExpressionBooleenne("\"TATA\"<=\"TATA\"");
+            new ExpressionBooleenne("\"TITI\" <= \"TATA\"");
+            new ExpressionBooleenne("\"TATA\" > \"FOO BAR\"");
+            new ExpressionBooleenne("\"FOO BAR\" > \"TATA\"");
+            new ExpressionBooleenne("\"TATA\" >= \"TATA\"");
+            new ExpressionBooleenne("\"FOO BAR\" >= \"TATA\"");
+            /* Expression logique sur des Chaines SANS ESPACES */
+            new ExpressionBooleenne("\"TATA\"=\"TATA\"");
+            new ExpressionBooleenne("\"TATA\"=\"TITI\"");
+            new ExpressionBooleenne("\"TATA\"<\"TITI\"");
+            new ExpressionBooleenne("\"TOTO\"<\"TITI\"");
+            new ExpressionBooleenne("\"TOTO\"<>\"TATA\"");
+            new ExpressionBooleenne("\"TATA\"<>\"TATA\"");
+            new ExpressionBooleenne("\"TATA\"<=\"TATA\"");
+            new ExpressionBooleenne("\"TITI\"<=\"TATA\"");
+            new ExpressionBooleenne("\"TATA\">\"FOO BAR\"");
+            new ExpressionBooleenne("\"FOO BAR\">\"TATA\"");
+            new ExpressionBooleenne("\"TATA\">=\"TATA\"");
+            new ExpressionBooleenne("\"FOO BAR\">=\"TATA\"");
+            /* Expression logique sur des Chaines MOITIE ESPACES */
+            new ExpressionBooleenne("        \"TATA\" = \"TATA\"");
+            new ExpressionBooleenne("\"TATA\"           = \"TITI\"");
+            new ExpressionBooleenne("\"TATA\" <          \"TITI\"");
+            new ExpressionBooleenne("\"TOTO\" < \"TITI\"       ");
+            new ExpressionBooleenne("     \"TOTO\"<> \"TATA\"       ");
+            new ExpressionBooleenne("\"TATA\"     <>     \"TATA\"     ");
+            new ExpressionBooleenne("        \"TATA\" <=\"TATA\"");
+            new ExpressionBooleenne("\"TITI\" <=       \"TATA\"");
+            new ExpressionBooleenne("      \"TATA\" > \"FOO BAR\"");
+            new ExpressionBooleenne("    \"FOO BAR    \"       > \"TATA\"");
+            new ExpressionBooleenne("\"TATA\"        >=         \"TATA\"");
+            new ExpressionBooleenne("            \"FOO BAR\" >=      \"TATA\"");
+            /* Expression logique sur des Chaines AVEC OPERATEURS */
+            new ExpressionBooleenne("\"FOO BAR\"<>\"TATA=TOTO\"");
+            new ExpressionBooleenne("\"FOO BAR=FLEMME\">\"TOTO\"");
+            new ExpressionBooleenne("\"FOO BAR > FLEMME\"=\"TOTO\"");
+            new ExpressionBooleenne("\"FOO BAR<>FLEMME\">\"TOTO\"");
+
+            /* Expression logique sur des IdEntier et Entiers */
+            new ExpressionBooleenne("marcel <= 10"); // true
+            new ExpressionBooleenne("marcel > j34n"); // false
+            new ExpressionBooleenne("2 = pi3rr3");
+            new ExpressionBooleenne("j34n = pi3rr3");
+            /* Expression logique sur des IdChaine et Chaines */
+            new ExpressionBooleenne("$sanchis < $barrios");
+            new ExpressionBooleenne("$servieres > \"Windows\"");
+            new ExpressionBooleenne("$barrios <> $servieres");
+            new ExpressionBooleenne("\"coucou\" = $barrios");
+        } catch (InterpreteurException lancee) {
+            echec();
+        }
+    }
+    
+    /** 
+     * Tests unitaire de {@link ExpressionBooleenne#calculer()}
+     */
+    public void testCalculer() {
+        
+        final Boolean[] VALEUR_ATTENDU_ID = {
+                true, false, true, false, true, false, true, false
+        };
+        
+        
+        Contexte contexteGlobal = new Contexte();
+        contexteGlobal.ajouterVariable(new IdentificateurEntier("marcel"),
+                                       new Entier(0));
+        contexteGlobal.ajouterVariable(new IdentificateurEntier("j34n"),
+                                       new Entier(1));
+        contexteGlobal.ajouterVariable(new IdentificateurEntier("pi3rr3"),
+                                       new Entier(2));
+        contexteGlobal.ajouterVariable(new IdentificateurChaine("$sanchis"),
+                new Chaine("\"coucou\""));
+        contexteGlobal.ajouterVariable(new IdentificateurChaine("$barrios"),
+                new Chaine("\"java\""));
+        contexteGlobal.ajouterVariable(new IdentificateurChaine("$servieres"),
+                new Chaine("\"WinDesign\""));
+        Expression.referencerContexte(contexteGlobal);
+
+        System.out.println("\tExécution du test de Calculer()");
+        for (int numTest = 0 ; numTest < VALEUR_ATTENDU_ID.length ; numTest++) {
+            assertEquivalence(VALEUR_ATTENDU_ID[numTest], 
+                              FIXTURE_ID[numTest].calculer().getValeur());
+        }
+        
+        final ExpressionBooleenne[] A_TESTER = {
+                new ExpressionBooleenne("1=1"),
+                new ExpressionBooleenne("1=2"),
+                new ExpressionBooleenne("1<2"),
+                new ExpressionBooleenne("1<1"),
+                new ExpressionBooleenne("1<>2"),
+                new ExpressionBooleenne("1<>1"),
+                new ExpressionBooleenne("1<=1"),
+                new ExpressionBooleenne("1<=5"),
+                new ExpressionBooleenne("1>-3"),
+                new ExpressionBooleenne("1>56"),
+                new ExpressionBooleenne("1>=1"),
+                new ExpressionBooleenne("1>=45"),
+                new ExpressionBooleenne("\"TATA\" = \"TATA\""),
+                new ExpressionBooleenne("\"TATA\" = \"TITI\""),
+                new ExpressionBooleenne("\"TATA\" < \"TITI\""),
+                new ExpressionBooleenne("\"TOTO\" < \"TITI\""),
+                new ExpressionBooleenne("\"TOTO\" <> \"TATA\""),
+                new ExpressionBooleenne("\"TATA\" <> \"TATA\""),
+                new ExpressionBooleenne("\"TATA\"<=\"TATA\""),
+                new ExpressionBooleenne("\"TITI\" <= \"TATA\""),
+                new ExpressionBooleenne("\"TATA\" > \"FOO BAR\""),
+                new ExpressionBooleenne("\"FOO BAR\" > \"TATA\""),
+                new ExpressionBooleenne("\"TATA\" >= \"TATA\""),
+                new ExpressionBooleenne("\"FOO BAR\" >= \"TATA\""),
+        };
+        
+        final Boolean[] VALEUR_ATTENDU_L = {
+                true, false, true, false, true, false, 
+                true, true, true, false, true, false, 
+                
+                true, false, true, false, true, false,
+                true, false, true, false, true, false
+        };
+        
+        for (int numTest = 0 ; numTest < A_TESTER.length ; numTest++) {
+          assertEquivalence(VALEUR_ATTENDU_L[numTest], 
+                            A_TESTER[numTest].calculer().getValeur());
+      }
+    }
+    
+    /** 
+     * Tests unitaire de {@link ExpressionBooleenne#toString()}
+     */
+    public void testToString() {
+        System.out.println("\tExécution du test de toString()");
+        
+        final String[] ATTENDU_L = {
+                "1 = 1",
+                "1 = 2",
+                "1 < 2",
+                "1 < 1",
+                "1 <> 2",
+                "1 <> 1",
+                "1 <= 1",
+                "1 <= 5",
+                "1 > -3",
+                "1 > 56",
+                "1 >= 1",
+                "1 >= 45",
+                "1 = 1",
+                "1 = 2",
+                "1 < 2",
+                "1 < 1",
+                "1 <> 2",
+                "1 <> 1",
+                "1 <= 1",
+                "1 <= 5",
+                "1 > -3",
+                "1 > 56",
+                "1 >= 1",
+                "1 >= 45",
+                "1 = 1",
+                "1 = 2",
+                "1 < 2",
+                "1 < 1",
+                "1 <> 2",
+                "1 <> 1",
+                "1 <= 1",
+                "1 <= 5",
+                "1 > -3",
+                "1 > 56",
+                "1 >= 1",
+                "1 >= 45",
+                "\"TATA\" = \"TATA\"",
+                "\"TATA\" = \"TITI\"",
+                "\"TATA\" < \"TITI\"",
+                "\"TOTO\" < \"TITI\"",
+                "\"TOTO\" <> \"TATA\"",
+                "\"TATA\" <> \"TATA\"",
+                "\"TATA\" <= \"TATA\"",
+                "\"TITI\" <= \"TATA\"",
+                "\"TATA\" > \"FOO BAR\"",
+                "\"FOO BAR\" > \"TATA\"",
+                "\"TATA\" >= \"TATA\"",
+                "\"FOO BAR\" >= \"TATA\"",
+                "\"TATA\" = \"TATA\"",
+                "\"TATA\" = \"TITI\"",
+                "\"TATA\" < \"TITI\"",
+                "\"TOTO\" < \"TITI\"",
+                "\"TOTO\" <> \"TATA\"",
+                "\"TATA\" <> \"TATA\"",
+                "\"TATA\" <= \"TATA\"",
+                "\"TITI\" <= \"TATA\"",
+                "\"TATA\" > \"FOO BAR\"",
+                "\"FOO BAR\" > \"TATA\"",
+                "\"TATA\" >= \"TATA\"",
+                "\"FOO BAR\" >= \"TATA\"",
+                "\"TATA\" = \"TATA\"",
+                "\"TATA\" = \"TITI\"",
+                "\"TATA\" < \"TITI\"",
+                "\"TOTO\" < \"TITI\"",
+                "\"TOTO\" <> \"TATA\"",
+                "\"TATA\" <> \"TATA\"",
+                "\"TATA\" <= \"TATA\"",
+                "\"TITI\" <= \"TATA\"",
+                "\"TATA\" > \"FOO BAR\"",
+                "\"FOO BAR    \" > \"TATA\"",
+                "\"TATA\" >= \"TATA\"",
+                "\"FOO BAR\" >= \"TATA\"",
+                "\"FOO BAR\" <> \"TATA=TOTO\"",
+                "\"FOO BAR=FLEMME\" > \"TOTO\"",
+                "\"FOO BAR > FLEMME\" = \"TOTO\"",
+                "\"FOO BAR<>FLEMME\" > \"TOTO\"",
+        };
+        
+        for (int numTest = 0 ; numTest < ATTENDU_L.length ; numTest++) {
+            assertEquivalence(ATTENDU_L[numTest], 
+                              FIXTURE_LITTERALE[numTest].toString());
+        }
+        
+        final String[] ATTENDU_I = {
+                "marcel <= 10",
+                "marcel > j34n",
+                "2 = pi3rr3",
+                "j34n = pi3rr3",
+                "$sanchis < $barrios",
+                "$servieres > \"Windows\"",
+                "$barrios <> $servieres",
+                "\"coucou\" = $barrios",
+        };
+        
+        for (int numTest = 0 ; numTest < ATTENDU_I.length ; numTest++) {
+            assertEquivalence(ATTENDU_I[numTest], 
+                              FIXTURE_ID[numTest].toString());
+        }
+    }
+}

src/interpreteurlir/expressions/tests/TestExpressionChaine.java

@@ -141,4 +141,33 @@ public class TestExpressionChaine {
         }
         
     }
+    
+    /**
+     * Tests unitaires de {@link ExpressionChaine#toString()}
+     */
+    public void testToString() {
+        final String[] chaineAttendue = {
+            "$chaine = \"texte\"",  
+            "$chaine = \"tata\"",
+            "$tata",
+            "\"une chaine de texte\"",
+            "$chaine = \"toto\" + \"titi\"",
+            "$chaine = $toto + \"titi\"",
+            "$chaine = \"toto\" + $titi",
+            "$chaine = $toto + $titi",
+            "\"toto\" + \"titi\"",
+            "$toto + \"titi\"",
+            "\"toto\" + $titi",
+            "$toto + $titi",
+            "\"ab=bc\"",
+            "$chaine = \"ab+cd\" + $toto",
+        };
+        
+        System.out.println("\tExécution du test de "
+                           + "ExpressionChaine#toString()");
+        for (int numTest = 0 ; numTest < chaineAttendue.length ; numTest++) {
+            assertEquivalence(chaineAttendue[numTest], 
+                              fixture[numTest].toString());
+        }
+    }
 }

src/interpreteurlir/expressions/tests/TestExpressionEntier.java

@@ -9,10 +9,7 @@ import static info1.outils.glg.Assertions.*;
 import interpreteurlir.Contexte;
 import interpreteurlir.ExecutionException;
 import interpreteurlir.InterpreteurException;
-import interpreteurlir.donnees.Identificateur;
-import interpreteurlir.donnees.IdentificateurChaine;
 import interpreteurlir.donnees.IdentificateurEntier;
-import interpreteurlir.donnees.litteraux.Chaine;
 import interpreteurlir.donnees.litteraux.Entier;
 import interpreteurlir.expressions.Expression;
 import interpreteurlir.expressions.ExpressionEntier;
@@ -67,7 +64,8 @@ public class TestExpressionEntier {
             "divisionRatee = 5 /",
             "ratee=*7",
         };
-        
+        System.out.println("\tExécution du test de "
+                           + "ExpressionEntier#ExpressionEntier(String)");
         for (String invalide : INVALIDES) {
             try {
                 new ExpressionEntier(invalide);
@@ -99,6 +97,9 @@ public class TestExpressionEntier {
             new Entier(0)   // Bouchon
         };
         
+        System.out.println("\tExécution du test de "
+                           + "ExpressionEntier#calculer()");
+        
         /* Exception levée si contexte non référencé */
         try {
             FIXTURE[0].calculer();
@@ -153,6 +154,9 @@ public class TestExpressionEntier {
                 "modulo = 12 % 0"
         };
         
+        System.out.println("\tExécution du test de "
+                           + "ExpressionEntier#toString()");
+        
         for (int i = 0 ; i < FIXTURE.length ; i++) {
             assertTrue(FIXTURE[i].toString().equals(ATTENDUES[i]));
         }

src/interpreteurlir/motscles/Commande.java

@@ -19,7 +19,7 @@ import interpreteurlir.programmes.Programme;
  * @author Heïa Dexter
  * @author Lucas Vabre
  */
-public class Commande {
+public abstract class Commande {
     
     /** référence du programme global */
     protected static Programme programmeGlobal;
@@ -52,10 +52,7 @@ public class Commande {
      * @return true si la commande affiche un feedback directement sur la sortie
      *         standard, sinon false
      */
-    public boolean executer() {
-        // pas de comportement pour une Commande générale
-        return false; // pas de feedback
-    }
+    public abstract boolean executer();
     
     /**
      * Référence le programme pour accéder et modifier le programme chargé.

src/interpreteurlir/motscles/CommandeCharge.java

@@ -0,0 +1,167 @@
+/**
+ * CommandeCharge.java                              21 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.motscles;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.ExecutionException;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.motscles.instructions.Instruction;
+import interpreteurlir.programmes.Etiquette;
+import interpreteurlir.Analyseur;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.lang.reflect.InvocationTargetException;
+
+/** 
+ * Charge les lignes de programme dans le fichier texte indiqué en argument
+ * 
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class CommandeCharge extends Commande{
+
+    /** Chemin du fichier dans lequel sera le programme chargé */
+    private String cheminFichier;
+ 
+    /**
+     * Initialise la commande Charge a partir de ses argument et 
+     * de son contexte passé en paramètre.
+     * @param arguments Chemin du fichier dans lequel sera le programme chargé
+     * @param contexte  Contexte du programme
+     * @throws InterpreteurException Si l'argument est null, vide,
+     *                               contient uniquement des espaces ou
+     *                               ne se termine pas par ".lir".
+     */
+    public CommandeCharge(String arguments, Contexte contexte ) {
+        super(arguments, contexte);
+
+        final String extension = ".lir";
+
+        if (arguments == null
+                || arguments.isEmpty()
+                || arguments.isBlank()
+                || !arguments.trim().endsWith(extension)) {
+
+            throw new InterpreteurException("\t" + arguments 
+                    + " n'est pas un chemin valide");
+        }
+
+        this.cheminFichier = arguments.trim();
+    }
+    
+    /**
+     * Charge le programme contenu dans le fichier de this
+     * @return false car elle n'affiche aucun feedback directement
+     * @throws InterpreteurException Si le fichier a charger n'as pas été trouvé
+     */
+    public boolean executer() {
+        
+        programmeGlobal.raz();
+        
+        /* Chemin du fichier */
+        String nomFichier = new File(cheminFichier).getAbsolutePath();
+        
+        /* Fichier logique en entrée */
+        BufferedReader entree;
+        
+        entree = null;
+        try {
+            entree = new BufferedReader(
+                         new InputStreamReader(
+                             new FileInputStream(nomFichier)));
+            analyserFichier(entree);
+            entree.close();
+        } catch (IOException e) {
+            throw new InterpreteurException(nomFichier + " est introuvable");
+        }
+        
+        return false;
+    }
+
+    /**
+     * Analyse chaque ligne de l'entrée et les ajoute dans programme global
+     * @param entree Tampon du fichier à lire
+     * @throws IOException Problème de lecture du fichier
+     */
+    private void analyserFichier(BufferedReader entree) throws IOException {
+        
+        /* Index de la ligne découpée */
+        final int ETIQUETTE = 0;
+        final int MOT_CLE = 1;
+        final int ARGUMENT = 2;
+        
+        String ligneLue;
+        int numLigne = 0;
+        
+        do {
+            ligneLue = entree.readLine();
+            if (ligneLue != null && !ligneLue.isBlank()) {
+                numLigne++;
+                
+                String[] decoupage = splitter(ligneLue);
+                
+                Class<?> aAjouter;
+                try {
+                    aAjouter = Analyseur
+                               .rechercheInstruction(decoupage[MOT_CLE]);
+                    
+                    Class<?> classeArg = String.class;
+                    Class<?> classeContexte = Contexte.class;
+                    Instruction inst = (Instruction)aAjouter
+                            .getConstructor(classeArg, classeContexte)
+                            .newInstance(decoupage[ARGUMENT], contexte);
+                    
+                    Etiquette etiquette = new Etiquette(decoupage[ETIQUETTE]);
+                    
+                    programmeGlobal.ajouterLigne(etiquette, inst);
+                } catch (InvocationTargetException| IllegalAccessException 
+                         |InstantiationException  | NoSuchMethodException 
+                         |InterpreteurException   | ExecutionException lancee) {
+                    programmeGlobal.raz();
+                    throw new InterpreteurException(ligneLue + " => ligne "
+                                                    + numLigne);
+                }
+            }
+        } while (ligneLue != null);
+    }
+
+    /**
+     * Sépare la ligne en etiquette/mot clé/argument
+     * @param ligneLue 
+     * @return Tableau comportant en :
+     *         <ul><li>indice 1 : l'étiquette</li>
+     *             <li>indice 2 : mot clé</li>
+     *             <li>indice 3 : argument</li></ul>
+     * @throws InterpreteurException Si la ligne ne contient pas les 2 éléments:
+     *                               <ul><li>Etiquette</li>
+     *                                   <li>Mot clé</li></ul>
+     */
+    private static String[] splitter(String ligneLue) {
+        /* Sépare l'étiquette, la commande et l'argument */
+        String[] ligne = ligneLue.split(" ", 3);
+        
+        if (ligne.length < 2) {
+            programmeGlobal.raz();
+            throw new InterpreteurException(ligneLue + " n'est pas "
+                                            + "une ligne valide");
+        }
+        
+        String[] decoupage = new String[3];
+        
+        /* Ajouter la ligne dans le contexte */
+        decoupage[0] = ligne[0];
+        decoupage[1] = ligne[1];
+        decoupage[2] = ligne.length >= 3 ? ligne[2] : "";
+        
+        return decoupage;
+    }
+}

src/interpreteurlir/motscles/CommandeDebut.java

@@ -39,7 +39,6 @@ public class CommandeDebut extends Commande {
         }
     }
     
-    
     /**
      * Commande d'exécution de la commande.
      * Efface le contexte.

src/interpreteurlir/motscles/CommandeEfface.java

@@ -21,7 +21,7 @@ public class CommandeEfface extends Commande {
     
     /** Erreur nombre incorrect d'arguments */
     private static final String ERREUR_NB_ARGS = 
-        "nombre d'arguments incorrect. Syntaxe attendue ==> <debut>:<fin>";
+        "usage efface <étiquette_début>:<étiquette_fin>";
     
     /** Plage de suppression des lignes de code */
     private Etiquette[] plageSuppression;
@@ -31,7 +31,7 @@ public class CommandeEfface extends Commande {
      * contexte passés en paramètres. Modifie le programme global référencé
      * par l'analyseur.
      * @param arguments lignes à effacer (tout le programme si vide)
-     * @param contexte
+     * @param contexte référence du contexte global
      */
     public CommandeEfface(String arguments, Contexte contexte) {
         super(arguments, contexte);

src/interpreteurlir/motscles/CommandeFin.java

@@ -36,7 +36,6 @@ public class CommandeFin extends Commande {
         }
     }
     
-    
     /**
      * Commande d'exécution de la commande.
      * Quitte l'interpreteur en affichant un message d'aurevoir.

src/interpreteurlir/motscles/CommandeLance.java

@@ -6,7 +6,6 @@ package interpreteurlir.motscles;
 
 import interpreteurlir.Contexte;
 import interpreteurlir.InterpreteurException;
-import interpreteurlir.programmes.Programme;
 import interpreteurlir.programmes.Etiquette;
 
 /** 
@@ -25,8 +24,8 @@ public class CommandeLance extends Commande {
 
     /** 
      * Initialise la commande lance avec ses arguments et le contexte
-     * @param arguments
-     * @param contexte
+     * @param arguments vide ou étiquette de lancement
+     * @param contexte référence du contexte global
      * @throws InterpreteurException en cas d'erreur de syntaxe à
      *                               la création d'une étiquette
      */

src/interpreteurlir/motscles/CommandeListe.java

@@ -28,8 +28,8 @@ public class CommandeListe extends Commande {
     /** 
      * Initialise la commande liste avec ses arguments et le contexte
      * 
-     * @param arguments
-     * @param contexte
+     * @param arguments arguments vide ou contenant les étiquettes à afficher
+     * @param contexte référence du contexte global
      * @throws InterpreteurException en cas d'erreur de syntaxe lors
      *                               de l'instanciation des étiquettes
      */
@@ -39,10 +39,10 @@ public class CommandeListe extends Commande {
         final int ARGS_DEBUT = 0;
         final int   ARGS_FIN = 1;
         
-        final String ERREUR_INTERVALLE = "usage <etiquette debut>:"
-                                         + "<etiquette fin> avec "
-                                         + "<etiquette debut> < "
-                                         + "<etiquette fin> ";
+        final String ERREUR_INTERVALLE = "usage liste <étiquette_début>:"
+                                         + "<étiquette_fin> avec "
+                                         + "<étiquette_début> <= "
+                                         + "<étiquette_fin> ";
         
         if (arguments.isBlank()) {
             debut = new Etiquette(VALEUR_ETIQUETTE_MIN);
@@ -75,12 +75,12 @@ public class CommandeListe extends Commande {
      *                          dans la classe {@link Commande}
      */
     public boolean executer() {
-
         final String ERREUR = "erreur exécution";
         
         if (programmeGlobal == null) {
             throw new RuntimeException(ERREUR);
         }
+        
         if (debut != null || fin != null) {
             System.out.print(programmeGlobal.listeBornee(debut, fin));
         }

src/interpreteurlir/motscles/CommandeSauve.java

@@ -0,0 +1,86 @@
+/**
+ * CommandeSauve.java                              21 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.motscles;
+
+import java.io.PrintStream;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.ExecutionException;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.programmes.Programme;
+
+/**
+ * Commande sauve prenant en argument le chemin du fichier 
+ * (avec une extension .lir) dans lequel est enregistré le programme chargé.
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class CommandeSauve extends Commande {
+
+    /** chemin du fichier d'extension .lir pour la sauvegarde */
+    private String cheminFichier;
+    
+    /**
+     * Initialise une commande sauve avec un chemin de fichier .lir passé en
+     * argument.
+     * @param arguments chemin du fichier dans lequel 
+     *                  la sauvegarde sera effectuée
+     * @param contexte référence du contexte global
+     * @throws InterpreteurException si le chemin du fichier n'a pas 
+     *                               l'extension .lir
+     *                               ou si arguments est chaîne blanche
+     */
+    public CommandeSauve(String arguments, Contexte contexte) {
+        super(arguments, contexte);
+        
+        final String EXTENSION = ".lir";
+        final String USAGE = "usage sauve <chemin_et_nom_du_fichier>.lir";
+        
+        arguments = arguments.trim();
+        
+        if (arguments.isBlank() || !arguments.endsWith(EXTENSION)) {
+            throw new InterpreteurException(USAGE);
+        }
+        // else
+        
+        cheminFichier = arguments;
+    }
+    
+    /**
+     * Commande d'exécution de la commande.
+     * Sauvegarde le programme référencé dans la classe Commande
+     * dans le fichier de cette CommandeSauve.
+     * @return false car aucun feedback afficher directement
+     * @throws ExecutionException si l'enregistrement est impossible
+     * @throws RuntimeException si aucun programme référencé dans la classe
+     *                          Commande avec la méthode
+     *                          {@link Commande#referencerProgramme(Programme)}
+     */
+    @Override
+    public boolean executer() {
+        final String MSG_ERREUR = "impossible de sauvegarder le programme "
+                + "dans le fichier (le chemin est peut-être invalide)";
+        
+        if (programmeGlobal == null) {
+            throw new RuntimeException("Programme non référencé dans Commande");
+        }
+        
+        PrintStream aEcrire = null;
+        
+        try {
+            aEcrire = new PrintStream(cheminFichier);
+            aEcrire.print(programmeGlobal.toString());
+            aEcrire.close();
+        } catch (Exception lancee) {
+            throw new ExecutionException(MSG_ERREUR);
+        }
+
+        return false;
+    }
+
+}

src/interpreteurlir/motscles/instructions/Instruction.java

@@ -17,10 +17,7 @@ import interpreteurlir.motscles.Commande;
  * @author Heïa Dexter
  * @author Lucas Vabre
  */
-public class Instruction extends Commande {
-
-    /** Contexte d'exécution de cette instruction */
-    protected Contexte contexteGlobal;
+public abstract class Instruction extends Commande {
     
     /** Expression qui sera exécutée par la commande */
     protected Expression aExecuter;
@@ -41,16 +38,12 @@ public class Instruction extends Commande {
      * @see interpreteurlir.motscles.Commande#executer()
      */
     @Override
-    public boolean executer() {
-        return super.executer();
-    }
+    public abstract boolean executer();
 
     /*
      * Non - javadoc
      * @see java.lang.Object#toString()
      */
     @Override
-    public String toString() {
-        return getClass().getSimpleName() + " " + aExecuter; 
-    }
+    public abstract String toString();
 }

src/interpreteurlir/motscles/instructions/InstructionAffiche.java

@@ -7,7 +7,6 @@ package interpreteurlir.motscles.instructions;
 import interpreteurlir.Contexte;
 import interpreteurlir.InterpreteurException;
 import interpreteurlir.expressions.Expression;
-import interpreteurlir.expressions.ExpressionChaine;
 
 /**
  * Affiche sur la sortie standard une expression passée en argument. Cette
@@ -21,8 +20,9 @@ import interpreteurlir.expressions.ExpressionChaine;
  */
 public class InstructionAffiche extends Instruction {
     
-    /** Erreur d'affectation illegale */
-    private static final String AFFECTATION_ILLEGALE = "affectation illegale";
+    /** Erreur d'affectation illégale */
+    private static final String AFFECTATION_ILLEGALE = 
+                              "affectation impossible avec la commande affiche";
 
     /**
      * Initialise cette InstructionAffiche à partir de son contexte global
@@ -37,8 +37,9 @@ public class InstructionAffiche extends Instruction {
     public InstructionAffiche(String arguments, Contexte contexte) {
         super(arguments, contexte);
 
-        if (ExpressionChaine.indexOperateur(arguments, '=') >= 0)
+        if (Expression.detecterCaractere(arguments, '=') >= 0) {
             throw new InterpreteurException(AFFECTATION_ILLEGALE);
+        }
         
         aExecuter = arguments.isBlank() 
                     ? null
@@ -70,5 +71,4 @@ public class InstructionAffiche extends Instruction {
                                               : " " + aExecuter.toString());
     }
     
-    
 }

src/interpreteurlir/motscles/instructions/InstructionEntre.java

@@ -44,7 +44,7 @@ public class InstructionEntre extends Instruction {
      */
     public InstructionEntre(String arguments, Contexte contexte) {
         super(arguments, contexte);
-        final String ERREUR_ARG = "Entre attend un identificateur en argument";
+        final String ERREUR_ARG = "usage entre <identificateur>";
         
         if (arguments.isBlank()) {
             throw new InterpreteurException(ERREUR_ARG);
@@ -68,8 +68,10 @@ public class InstructionEntre extends Instruction {
      */
     public boolean executer() {
         
-        final String MESSAGE_ERREUR_TYPE = "Le type saisi ne correspond"
-                                           + " pas au type demandé";
+        final String MESSAGE_ERREUR_TYPE = "type saisi "
+                                           + "et type demandé incompatibles";
+        
+        @SuppressWarnings("resource") // ne pas fermer sinon crash
         Scanner entree = new Scanner(System.in);
         
         String valeurSaisie = entree.nextLine();
@@ -84,6 +86,7 @@ public class InstructionEntre extends Instruction {
         } catch (InterpreteurException lancee) {
             throw new ExecutionException(MESSAGE_ERREUR_TYPE);
         }
+        
         return false;
     }
 

src/interpreteurlir/motscles/instructions/InstructionProcedure.java

@@ -5,7 +5,6 @@
 package interpreteurlir.motscles.instructions;
 
 import interpreteurlir.Contexte;
-import interpreteurlir.ExecutionException;
 import interpreteurlir.InterpreteurException;
 import interpreteurlir.programmes.Etiquette;
 
@@ -36,7 +35,7 @@ public class InstructionProcedure extends Instruction {
     public InstructionProcedure(String arguments, Contexte contexte) {
         super(arguments, contexte);
         
-        final String ERREUR_ARG = "procedure attend une étiquette en argument";
+        final String ERREUR_ARG = "usage procedure <étiquette>";
         
         if(arguments.isBlank()) {
             throw new InterpreteurException(ERREUR_ARG);
@@ -63,7 +62,6 @@ public class InstructionProcedure extends Instruction {
      *                          de classe de Commande.
      */
     public boolean executer() {
-        
         final String ERREUR_REFERENCEMENT = "Le programme doit être référencé "
                                             + "dans la classe commande";
         

src/interpreteurlir/motscles/instructions/InstructionRetour.java

@@ -32,7 +32,7 @@ public class InstructionRetour extends Instruction {
     public InstructionRetour(String arguments, Contexte contexte) {
         super(arguments, contexte);
         
-        final String ERREUR_ARG = "L'instruction retour n'a pas d'arguments";
+        final String ERREUR_ARG = "l'instruction retour n'a pas d'arguments";
         
         if (!arguments.isBlank()) {
             throw new InterpreteurException(ERREUR_ARG);

src/interpreteurlir/motscles/instructions/InstructionSi.java

@@ -0,0 +1,94 @@
+/**
+ * InstructionSi.java                              22 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.motscles.instructions;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.ExecutionException;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.expressions.ExpressionBooleenne;
+import interpreteurlir.programmes.Etiquette;
+
+/**
+ * Instruction de saut conditionnel.
+ * La syntaxe est "si expression_booléenne vaen etiquette".
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class InstructionSi extends Instruction {
+    
+    /** expression booléenne de this qui est la condition du saut */
+    private ExpressionBooleenne condition;
+    
+    /** etiquette pour le saut conditionnel */
+    private Etiquette saut;
+
+    /**
+     * Initialise une instruction de saut conditionnel à partir des arguments
+     * @param arguments chaîne argument de la forme 
+     *                  "si expression_booléenne vaen etiquette"
+     * @param contexte contexte global
+     * @throws InterpreteurException si syntaxe invalide (si ... vaen ...)
+     *                               ou si expression_booléenne invalide 
+     *                               ou si etiquette invalide
+     */
+    public InstructionSi(String arguments, Contexte contexte) {
+        super(arguments, contexte);
+        final String ERR_SYNTAXE = "usage si <expression_booléenne>"
+                                   + " vaen <étiquette>";
+        
+        arguments = arguments.trim();
+        if (arguments.isBlank()) {
+            throw new InterpreteurException(ERR_SYNTAXE);
+        }
+        
+        int indexVaen = arguments.lastIndexOf("vaen");
+        if (indexVaen < 1) {
+            throw new InterpreteurException(ERR_SYNTAXE);
+        }
+        
+        String expression = arguments.substring(0, indexVaen);
+        String etiquette = arguments.substring(indexVaen + 4,
+                                               arguments.length());
+        
+        condition = new ExpressionBooleenne(expression);
+        saut = new Etiquette(etiquette);
+        
+    }
+
+    /**
+     * Execution de l'instruction :
+     * Realise un saut a l'étiquette spécifiée 
+     * si l'expression booléenne est true.
+     * @return false car aucun feedback affiché directement
+     * @throws RuntimeException si un programme n'est pas référencé en membre
+     *                          de classe de Commande.
+     * @throws ExecutionException si l'étiquette n'existe pas dans le programme
+     */
+    @Override
+    public boolean executer() {
+        final String ERREUR_REFERENCEMENT = "Le programme doit être référencé "
+                + "dans la classe commande";
+
+        if (programmeGlobal == null) {
+            throw new RuntimeException(ERREUR_REFERENCEMENT);
+        }
+        
+        if (condition.calculer().getValeur()) {
+            programmeGlobal.vaen(saut);
+        }
+        return false;
+    }
+
+    /* non javadoc
+     * @see interpreteurlir.motscles.instructions.Instruction#toString()
+     */
+    @Override
+    public String toString() {
+        return "si " + condition + " vaen " + saut;
+    }
+}

src/interpreteurlir/motscles/instructions/InstructionStop.java

@@ -6,7 +6,6 @@ package interpreteurlir.motscles.instructions;
 
 import interpreteurlir.Contexte;
 import interpreteurlir.InterpreteurException;
-import interpreteurlir.programmes.Programme;
 
 /**
  * Instruction stop servant à marquer la fin d'un programme de l'interpréteur
@@ -22,7 +21,8 @@ public class InstructionStop extends Instruction {
 
     /** Message d'erreur si instruction passée avec des arguments */
     private static final String ERREUR_ARGUMENTS = 
-            "l'instruction stop n'accepte pas d'arguments";
+            "l'instruction stop n'a pas d'arguments";
+    
     /**
      * Initialise cette instruction stop à partir des arguments, du contexte
      * et du programme passés en paramètres. Cette instruction ne modifie que

src/interpreteurlir/motscles/instructions/InstructionVaen.java

@@ -30,7 +30,7 @@ public class InstructionVaen extends Instruction {
     public InstructionVaen(String arguments, Contexte contexte) {
         super(arguments, contexte);
         
-        final String ERREUR_ARG = "vaen attend une étiquette en argument";
+        final String ERREUR_ARG = "usage vaen <étiquette>";
         
         if (arguments.isBlank()) {
             throw new InterpreteurException(ERREUR_ARG);
@@ -49,16 +49,15 @@ public class InstructionVaen extends Instruction {
 
     /**
      * Execution de l'instruction :
-     * Realise un saut a l'étiquette spécifiée.
-     * L'appel s'empile sur le contexte appellant pour ce qui est du
-     * compteur ordinal.
+     * Réalise un saut à l'étiquette spécifiée.
      * @return false car aucun feedback affiché directement
      * @throws RuntimeException si un programme n'est pas référencé en membre
      *                          de classe de Commande.
      */
     public boolean executer() {
         
-        final String ERREUR = "erreur exécution";
+        final String ERREUR = "Le programme doit être référencé "
+                              + "dans la classe commande";
         
         if (programmeGlobal == null) {
             throw new RuntimeException(ERREUR);

src/interpreteurlir/motscles/instructions/InstructionVar.java

@@ -7,7 +7,6 @@ package interpreteurlir.motscles.instructions;
 import interpreteurlir.Contexte;
 import interpreteurlir.InterpreteurException;
 import interpreteurlir.expressions.Expression;
-import interpreteurlir.expressions.ExpressionChaine;
 
 /**
  * Instruction de déclaration et d'affectation de variables. La syntaxe de
@@ -30,10 +29,11 @@ public class InstructionVar extends Instruction {
      */
     public InstructionVar(String arguments, Contexte contexte) {
         super(arguments, contexte);
+        final String USAGE = "usage var <identificateur> = <expression>";
         
         if (arguments == null || arguments.isBlank() 
-                || ExpressionChaine.indexOperateur(arguments, '=') <= 0)
-            throw new InterpreteurException("erreur de syntaxe");
+                || Expression.detecterCaractere(arguments, '=') <= 0)
+            throw new InterpreteurException(USAGE);
         
         aExecuter = Expression.determinerTypeExpression(arguments.trim());
     }

src/interpreteurlir/motscles/instructions/tests/TestInstruction.java

@@ -1,52 +1,45 @@
-/**
- * TestInstruction.java                                             9 mai 2021
- * IUT info1 2020-2021, pas de copyright, aucun droit
- */
-package interpreteurlir.motscles.instructions.tests;
+// Classe testée passé en abstract
 
-import interpreteurlir.Contexte;
-import interpreteurlir.motscles.instructions.Instruction;
-
-/**
- * Tests unitaires des instructions
- * @author Nicolas Caminade
- * @author Sylvan Courtiol
- * @author Pierre Debas
- * @author Heïa Dexter
- * @author Lucas Vabre
- */
-public class TestInstruction {
-    
-    /**
-     * Test du constructeur
-     */
-    public static void testInstruction() {
-        System.out.println("Test du constructeur");
-        Instruction aTester = new Instruction("Bonjour", new Contexte());
-        System.out.println("==> OK\n");
-    }
-    
-    /**
-     * Test de toString()
-     */
-    public static void testToString() {
-        System.out.println("Test de toString()");
-        Instruction aTester = new Instruction("Bonjour", new Contexte());
-        
-        if (!aTester.toString().equals("Instruction null"))
-            System.err.println("Echec du test");
-        else
-            System.out.println("==> OK\n");
-        
-        System.out.println(aTester);
-    }
-    
-    /**
-     * Lancement des tests
-     * @param args non utilisé
-     */
-    public static void main(String[] args) {
-        testInstruction();
-        testToString();
-    }
-}
+///**
+// * TestInstruction.java                                             9 mai 2021
+// * IUT info1 2020-2021, pas de copyright, aucun droit
+// */
+//package interpreteurlir.motscles.instructions.tests;
+//
+//import static info1.outils.glg.Assertions.*;
+//import interpreteurlir.Contexte;
+//import interpreteurlir.InterpreteurException;
+//import interpreteurlir.motscles.instructions.Instruction;
+//
+///**
+// * Tests unitaires des instructions
+// * 
+// * @author Nicolas Caminade
+// * @author Sylvan Courtiol
+// * @author Pierre Debas
+// * @author Heïa Dexter
+// * @author Lucas Vabre
+// */
+//public class TestInstruction {
+//    
+//    /**
+//     * Test unitaire de {@link Instruction#Instruction(String, Contexte)}
+//     */
+//    public static void testInstruction() {
+//        System.out.println("\tExécution du test de Instruction()");
+//        try {
+//            new Instruction("Bonjour", new Contexte());
+//        } catch (InterpreteurException lancee) {
+//            echec();
+//        }
+//    }
+//    
+//    /**
+//     * Test unitaire de {@link Instruction#toString()}
+//     */
+//    public static void testToString() {
+//        System.out.println("\tExécution du test de toString()");
+//        Instruction aTester = new Instruction("Bonjour", new Contexte());
+//        assertEquivalence(aTester.toString(), "Instruction null");
+//    }
+//}

src/interpreteurlir/motscles/instructions/tests/TestInstructionAffiche.java

@@ -56,7 +56,7 @@ public class TestInstructionAffiche {
         };
         
         Expression.referencerContexte(CONTEXTE_GBL);
-        System.out.println("Exécution du test de InstructionAffiche(String"
+        System.out.println("\tExécution du test de InstructionAffiche(String"
                            + ", Contexte)");
         for (String argInvalide : INVALIDES) {
             try {
@@ -73,12 +73,14 @@ public class TestInstructionAffiche {
      */
     public static void testExecuter() {
         
-        System.out.println("Exécution du test de executer()\nTEST VISUEL SUR "
+        System.out.println("\tExécution du test de executer()\nTEST VISUEL SUR "
                            + "CONSOLE :");
         
         Expression.referencerContexte(CONTEXTE_GBL);
-        for (InstructionAffiche aLancer : FIXTURE)
+        for (InstructionAffiche aLancer : FIXTURE) {
+            System.out.println("\n\ttest visuel suivant : ");
             aLancer.executer(); 
+        }
         
         System.out.println();
     }
@@ -100,7 +102,7 @@ public class TestInstructionAffiche {
             "affiche \"300000000000000000 ça passe\""
         };
         
-        System.out.println("Exécution du test de toString()");
+        System.out.println("\tExécution du test de toString()");
         for (int i = 0 ; i < FIXTURE.length ; i++) {
             assertTrue(FIXTURE[i].toString().compareTo(ATTENDUS[i]) == 0);
         }

src/interpreteurlir/motscles/instructions/tests/TestInstructionEntre.java

@@ -8,7 +8,6 @@ import interpreteurlir.motscles.instructions.InstructionEntre;
 import interpreteurlir.Contexte;
 import interpreteurlir.ExecutionException;
 import interpreteurlir.InterpreteurException;
-import interpreteurlir.donnees.litteraux.Entier;
 
 import static info1.outils.glg.Assertions.*;
 /** 
@@ -117,5 +116,4 @@ public class TestInstructionEntre {
         System.out.println("Contexte : \n" + CONTEXTE_GLB);
     }
     
-
 }

src/interpreteurlir/motscles/instructions/tests/TestInstructionSi.java

@@ -0,0 +1,184 @@
+/**
+ * TestInstructionSi.java                              22 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.motscles.instructions.tests;
+
+import interpreteurlir.motscles.Commande;
+import interpreteurlir.motscles.instructions.InstructionSi;
+import interpreteurlir.motscles.instructions.InstructionVar;
+import interpreteurlir.programmes.*;
+import interpreteurlir.Contexte;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.donnees.*;
+import interpreteurlir.donnees.litteraux.*;
+import interpreteurlir.expressions.Expression;
+
+import static info1.outils.glg.Assertions.*;
+
+/**
+ * Tests unitaires de {@link InstructionSi}
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class TestInstructionSi {
+
+    /** contexte pour les tests */
+    private Contexte contexte = new Contexte();
+    
+    /** programme pour les tests */
+    private Programme prog = new Programme();
+    
+    /** Jeu de donnée d'instruction si vaen valides pour les tests*/
+    private InstructionSi[] fixture = {
+        new InstructionSi("45 = 2 vaen 15", contexte),
+        new InstructionSi("age >= 130 vaen 1000", contexte),
+        new InstructionSi("$prenom <>\"défaut\" vaen 16", contexte),
+        new InstructionSi("resultat    < 20 vaen 17", contexte),
+        new InstructionSi("resultat < moyenne vaen 18", contexte),
+        new InstructionSi("age > 20 vaen   19", contexte),
+        new InstructionSi("\"tata\"    = \"tata\"vaen 20", contexte),
+        new InstructionSi("\"toto  \" > $toto vaen1502", contexte),
+        new InstructionSi("-5 <= 0 vaen 21", contexte),
+        new InstructionSi("resultat < 20    vaen 22", contexte),
+    };
+    
+    /**
+     * Tests unitaires de {@link InstructionSi#InstructionSi(String, Contexte)}
+     */
+    public void testInstructionSiStringContexte() {
+        final String[] ARGS_INVALIDES = {
+            "",
+            "   \t",
+            " entier < index",
+            "vaen 1050",
+            "age = 10 vaen",
+            " $prenom = \"défaut\" va 10",
+            "$prenom <> $nom  goto 45",
+            "$prenom <> $nom  vaen dix",
+            "$prenom != $nom  vaen 45",
+            /* erreur de type */
+            "$prenom <> 5 vaen 450",
+            "age > \"\" vaen 450",
+            "age >= $prenom vaen 450",
+            "\"dix\" = 10 vaen 4500",
+        };
+        
+        System.out.println("\tExécution du test de "
+                           + "InstructionSi#InstructionSi(String, Contexte)");
+        
+        for (String aTester : ARGS_INVALIDES) {
+            try {
+                new InstructionSi(aTester, contexte);
+                echec();
+            } catch (InterpreteurException lancee) {
+                // testok
+            }
+        }
+        
+        try {
+            new InstructionSi("45 = 2 vaen 15", contexte);
+            new InstructionSi("age >= 130 vaen 1000", contexte);
+            new InstructionSi("$prenom <>\"défaut\" vaen 15", contexte);
+            new InstructionSi("resultat    < 20 vaen 15", contexte);
+            new InstructionSi("resultat < moyenne vaen 15", contexte);
+            new InstructionSi("age > 20 vaen   15", contexte);
+            new InstructionSi("\"tata\"    = \"tata\"vaen 15", contexte);
+            new InstructionSi("\"toto  \" > $toto vaen1502", contexte);
+            new InstructionSi("-5 <= 0 vaen 15", contexte);
+            new InstructionSi("resultat < 20    vaen 15", contexte);
+            new InstructionSi("$chaine <= \"vaen 15\"    vaen 15", contexte);
+        } catch (InterpreteurException lancee) {
+            echec();
+        }
+    }
+    
+    /**
+     * Tests unitaires de {@link InstructionSi#toString()}    
+     */
+    public void testToString() {
+        final String[] ATTENDU = {
+            "si 45 = 2 vaen 15",
+            "si age >= 130 vaen 1000",
+            "si $prenom <> \"défaut\" vaen 16",
+            "si resultat < 20 vaen 17",
+            "si resultat < moyenne vaen 18",
+            "si age > 20 vaen 19",
+            "si \"tata\" = \"tata\" vaen 20",
+            "si \"toto  \" > $toto vaen 1502",
+            "si -5 <= 0 vaen 21",
+            "si resultat < 20 vaen 22",
+        };
+        System.out.println("\tExécution du test de InstructionSi#toString()");
+        
+        for (int numTest = 0 ; numTest < ATTENDU.length ; numTest++) {
+            assertEquivalence(ATTENDU[numTest], fixture[numTest].toString());
+        }
+    }
+    
+    /**
+     * Tests unitaires de {@link InstructionSi#executer()}
+     */
+    public void testExecuter() {
+        Commande.referencerProgramme(prog);
+        prog.ajouterLigne(new Etiquette(15), 
+                new InstructionVar("valeur = valeur -1", contexte));
+        prog.ajouterLigne(new Etiquette(16), 
+                new InstructionVar("valeur = valeur -1", contexte));
+        prog.ajouterLigne(new Etiquette(17), 
+                new InstructionVar("valeur = valeur -1", contexte));
+        prog.ajouterLigne(new Etiquette(18), 
+                new InstructionVar("valeur = valeur -1", contexte));
+        prog.ajouterLigne(new Etiquette(19), 
+                new InstructionVar("valeur = valeur -1", contexte));
+        prog.ajouterLigne(new Etiquette(20), 
+                new InstructionVar("valeur = valeur -1", contexte));
+        prog.ajouterLigne(new Etiquette(21), 
+                new InstructionVar("valeur = valeur -1", contexte));
+        prog.ajouterLigne(new Etiquette(22), 
+                new InstructionVar("valeur = valeur -1", contexte));
+        prog.ajouterLigne(new Etiquette(1000), 
+                new InstructionVar("valeur = valeur -1", contexte));
+        prog.ajouterLigne(new Etiquette(1502), 
+                new InstructionVar("valeur = valeur -1", contexte));
+        Expression.referencerContexte(contexte);
+
+        
+        final int[] VALEUR_ATTENDU = {
+            0, // pas de saut
+            0,
+            -9, // saut en 16
+            -8, // saut en 17
+            0,
+            -6, // saut en 19
+            -5, // saut en 20
+            -1, // saut en 1502
+            -4, // saut en 21
+            -3, // saut en 22
+        };
+        
+        System.out.println("\tExécution du test de InstructionSi#executer()");
+        
+        for (int numTest = 0 ; numTest < VALEUR_ATTENDU.length ; numTest++) {
+            /* initialisation du contexte */
+            contexte.raz();
+            contexte.ajouterVariable(new IdentificateurEntier("moyenne"), 
+                    new Entier("-2"));
+            contexte.ajouterVariable(new IdentificateurEntier("age"), 
+                    new Entier("99"));
+            contexte.ajouterVariable(new IdentificateurChaine("$toto"), 
+                    new Chaine("\"toto\""));
+            
+            fixture[numTest].executer();
+            assertEquivalence(VALEUR_ATTENDU[numTest], 
+                              ((Integer)contexte.lireValeurVariable(
+                                      new IdentificateurEntier("valeur"))
+                                      .getValeur()).intValue());
+        } 
+    }
+    
+
+}

src/interpreteurlir/motscles/instructions/tests/TestInstructionStop.java

@@ -44,7 +44,7 @@ public class TestInstructionStop {
             "entier = 2 + 3"
         };
         
-        System.out.println("Exécution du test de InstructionStop"
+        System.out.println("\tExécution du test de InstructionStop"
                            + "(String, Contexte)");
         for (String aTester : INVALIDES) {
             try {
@@ -59,32 +59,34 @@ public class TestInstructionStop {
     /** Test de executer() */
     public static void testExecuter() {
         Programme pgmTest = new Programme();
-        System.out.println("Exécution du test de executer()\ntestVisuel\n");
+        System.out.println("\tExécution du test de executer()\nTest Visuels\n");
         Commande.referencerProgramme(pgmTest);
         Expression.referencerContexte(CONTEXTE_TESTS);
         pgmTest.ajouterLigne(new Etiquette(10), 
-                new InstructionAffiche("Bonjour", CONTEXTE_TESTS));
+                new InstructionAffiche("\"Bonjour\"", CONTEXTE_TESTS));
         pgmTest.ajouterLigne(new Etiquette(20), 
-                new InstructionAffiche("Comment", CONTEXTE_TESTS));
+                new InstructionAffiche("\"Comment\"", CONTEXTE_TESTS));
         pgmTest.ajouterLigne(new Etiquette(30), 
-                new InstructionAffiche("Allez", CONTEXTE_TESTS));
+                new InstructionAffiche("\"Allez\"", CONTEXTE_TESTS));
         pgmTest.ajouterLigne(new Etiquette(40), 
-                new InstructionAffiche("Vous", CONTEXTE_TESTS));
+                new InstructionAffiche("\"Vous\"", CONTEXTE_TESTS));
         pgmTest.ajouterLigne(new Etiquette(45), 
                 new InstructionStop("", CONTEXTE_TESTS));
         pgmTest.ajouterLigne(new Etiquette(50), 
-                new InstructionAffiche("foobar", CONTEXTE_TESTS));
+                new InstructionAffiche("\"foobar\"", CONTEXTE_TESTS));
         System.out.println(pgmTest);
         System.out.println("lancement du programme : ne doit pas "
                            + "afficher foobar");
         pgmTest.lancer();
+        
+        System.out.println();
     }
     
     /** Tests de toString() */
     public static void testToString() {
         
         final String ATTENDUE = "stop";
-        System.out.println("Exécution du test de toString()");
+        System.out.println("\tExécution du test de toString()");
         for (InstructionStop valide : FIXTURE)
              assertTrue(valide.toString().compareTo(ATTENDUE) == 0);
     }

src/interpreteurlir/motscles/instructions/tests/TestInstructionVar.java

@@ -4,12 +4,14 @@
  */
 package interpreteurlir.motscles.instructions.tests;
 
+import static info1.outils.glg.Assertions.*;
 import interpreteurlir.Contexte;
 import interpreteurlir.InterpreteurException;
 import interpreteurlir.motscles.instructions.InstructionVar;
 
 /**
- * Tests unitaires de l'instruction var
+ * Tests unitaires de la classe InstructionVar
+ * 
  * @author Nicolas Caminade
  * @author Sylvan Courtiol
  * @author Pierre Debas
@@ -25,59 +27,50 @@ public class TestInstructionVar {
     };
 
     /**
-     * Test du constructeur InstructionVar
+     * Test unitaire de {@link InstructionVar#InstructionVar(String, Contexte)}
      */
     public static void testInstructionVar() {
         final String[] EXPRESSIONS_INVALIDES = {
-            "bonjour", "", null, "$toto $tata", 
+            "bonjour", "", "$toto $tata",
         };
         
-        System.out.println("Test du constructeur\navec expressions invalides");
+        System.out.println("\tExécution du test de InstructionVar(String, "
+                           + "Contexte)");
+        
         for (String aTester : EXPRESSIONS_INVALIDES) {
             try {
                 new InstructionVar(aTester, new Contexte());
-                throw new RuntimeException("Echec du test");
+                echec();
             } catch (InterpreteurException lancee) {
-                System.out.println(aTester + " ==> OK");
+                // Test OK
             }
         }
         
-        System.out.println("Avec expressions valides");
-        for (String aTester : VALIDES)
+        for (String aTester : VALIDES) {
+            try {
                 new InstructionVar(aTester, new Contexte());
-        
-        System.out.println("Fin du test\n");
+            } catch (InterpreteurException lancee) {
+                echec();
+            }
+        }
     }
     
     /**
-     * Test de toString
+     * Test unitaire de {@link InstructionVar#toString()}
      */
     public static void testToString() {
         final String[] CHAINES_ATTENDUES = {
-                "var $toto = $tata", "var entier=2+2", 
-                "var $coucou = $toto + \\\"titi\\\"", 
+                "var $toto = $tata", 
+                "var entier = 2 + 2", 
+                "var $coucou = $toto + \"titi\"", 
                 "var anneeNaissance = 1898"
         };
         
-        System.out.println("Test de toString()");
+        System.out.println("\tExécution du tes de toString()");
         for (int i = 0 ; i < VALIDES.length ; i++) {
-            
-            try {
-                assert VALIDES[i].toString().equals(CHAINES_ATTENDUES[i]);
-            } catch (AssertionError lancee) {
-                System.err.println("Echec du test à l'indice " + i);
+            InstructionVar aTester = new InstructionVar(VALIDES[i], 
+                                                        new Contexte());
+            assertTrue(CHAINES_ATTENDUES[i].equals(aTester.toString()));
         }
     }
-        System.out.println("Fin du test\n");
-    }
-    
-    /**
-     * Lancement des tests
-     * @param args
-     */
-    public static void main(String[] args) {
-        testInstructionVar();
-        testToString();
-    }
-
 }

src/interpreteurlir/motscles/tests/EssaiCommande.java

@@ -7,6 +7,7 @@ package interpreteurlir.motscles.tests;
 import interpreteurlir.Contexte;
 import interpreteurlir.InterpreteurException;
 import interpreteurlir.motscles.*;
+import interpreteurlir.programmes.Programme;
 
 /**
  * Essais des commandes (création + éxécution)
@@ -24,6 +25,7 @@ public class EssaiCommande {
      */
     public static void main(String[] args) {
         Contexte contexte = new Contexte();
+        Commande.referencerProgramme(new Programme());
         
         /* Erreur dans commande */
         System.out.println("? debut args");
@@ -49,9 +51,11 @@ public class EssaiCommande {
         System.out.println("? debut");
         feedback(new CommandeDebut("", contexte).executer());
         System.out.println("? defs");
-        feedback(new CommandeDefs( "", contexte).executer());
+        feedback(new CommandeDefs("", contexte).executer());
+        System.out.println("? liste");
+        feedback(new CommandeListe("", contexte).executer());
         System.out.println("? fin");
-        feedback(new CommandeFin(  "", contexte).executer());
+        feedback(new CommandeFin("", contexte).executer());
         
         System.err.println("Erreur, la commande fin n'a pas quitter");
 

src/interpreteurlir/motscles/tests/TestCommande.java

@@ -1,88 +1,90 @@
-/**
- * TestCommande.java                              7 mai 2021
- * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
- */
-package interpreteurlir.motscles.tests;
+// Classe testée passé en abstract
 
-import static info1.outils.glg.Assertions.*;
-
-import interpreteurlir.Contexte;
-import interpreteurlir.expressions.Expression;
-import interpreteurlir.motscles.Commande;
-import interpreteurlir.programmes.Programme;
-
-/**
- * Tests unitaires de {@link interpreteurlir.motscles.Commande}
- * @author Nicolas Caminade
- * @author Sylvan Courtiol
- * @author Pierre Debas
- * @author Heïa Dexter
- * @author Lucas Vabre
- */
-public class TestCommande {
- 
-    /** Jeux d'essais de Commande valides pour les tests */
-    private Commande[] fixture = { 
-            new Commande("", new Contexte()),
-            new Commande("coucou", new Contexte()),
-            new Commande("$chaine = \"toto\" + $tata", new Contexte())
-    };
-    
-    /**
-     * Tests unitaires de {@link Commande#referencerProgramme(Programme)}
-     */
-    public void testReferencerProgramme() {
-
-        Programme reference = new Programme();
-        Programme[] programmes = {
-                null, reference, reference, new Programme()
-        };
-        
-        boolean[] resultatAttendu = { false, true, true, false };
-        
-        System.out.println("\tExécution du test de "
-                + "Commande#referencerProgramme(Programme)");
-        for (int numTest = 0 ; numTest < programmes.length ;  numTest++) {
-            assertTrue(   Commande.referencerProgramme(programmes[numTest]) 
-                       == resultatAttendu[numTest]);
-        }
-    }
-    
-    /**
-     * Tests unitaires de {@link Commande#Commande(String, Contexte)}
-     */
-    public void testCommandeStringContexte() {
-        System.out.println(
-                "\tExécution du test de Commande#Commande(String, Contexte)");
-        
-        /* Tests Commande invalide */
-        String[] arguments = { null, null, "" };
-        Contexte[] contexte = { null, new Contexte(), null};
-        for (int numTest = 0 ; numTest < arguments.length ; numTest++) {
-            try {
-                new Commande(arguments[numTest], contexte[numTest]);
-                echec();
-            } catch (NullPointerException lancee) { 
-            }
-        }
-        
-        try {
-            new Commande("", new Contexte());
-            new Commande("coucou", new Contexte());
-            new Commande("$chaine = \"toto\" + $tata", new Contexte());
-        } catch (NullPointerException e) {
-            echec();
-        }
-    }
-    
-    
-    /**
-     * Tests unitaires de {@link Commande#executer()}
-     */
-    public void testExecuter() {
-        System.out.println("\tExécution du test de Commande#executer()");
-        for (Commande aTester : fixture) {
-            assertFalse(aTester.executer());
-        }
-    }
-}
+///**
+// * TestCommande.java                              7 mai 2021
+// * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+// */
+//package interpreteurlir.motscles.tests;
+//
+//import static info1.outils.glg.Assertions.*;
+//
+//import interpreteurlir.Contexte;
+//import interpreteurlir.expressions.Expression;
+//import interpreteurlir.motscles.Commande;
+//import interpreteurlir.programmes.Programme;
+//
+///**
+// * Tests unitaires de {@link interpreteurlir.motscles.Commande}
+// * @author Nicolas Caminade
+// * @author Sylvan Courtiol
+// * @author Pierre Debas
+// * @author Heïa Dexter
+// * @author Lucas Vabre
+// */
+//public class TestCommande {
+// 
+//    /** Jeux d'essais de Commande valides pour les tests */
+//    private Commande[] fixture = { 
+//            new Commande("", new Contexte()),
+//            new Commande("coucou", new Contexte()),
+//            new Commande("$chaine = \"toto\" + $tata", new Contexte())
+//    };
+//    
+//    /**
+//     * Tests unitaires de {@link Commande#referencerProgramme(Programme)}
+//     */
+//    public void testReferencerProgramme() {
+//
+//        Programme reference = new Programme();
+//        Programme[] programmes = {
+//                null, reference, reference, new Programme()
+//        };
+//        
+//        boolean[] resultatAttendu = { false, true, true, false };
+//        
+//        System.out.println("\tExécution du test de "
+//                + "Commande#referencerProgramme(Programme)");
+//        for (int numTest = 0 ; numTest < programmes.length ;  numTest++) {
+//            assertTrue(   Commande.referencerProgramme(programmes[numTest]) 
+//                       == resultatAttendu[numTest]);
+//        }
+//    }
+//    
+//    /**
+//     * Tests unitaires de {@link Commande#Commande(String, Contexte)}
+//     */
+//    public void testCommandeStringContexte() {
+//        System.out.println(
+//                "\tExécution du test de Commande#Commande(String, Contexte)");
+//        
+//        /* Tests Commande invalide */
+//        String[] arguments = { null, null, "" };
+//        Contexte[] contexte = { null, new Contexte(), null};
+//        for (int numTest = 0 ; numTest < arguments.length ; numTest++) {
+//            try {
+//                new Commande(arguments[numTest], contexte[numTest]);
+//                echec();
+//            } catch (NullPointerException lancee) { 
+//            }
+//        }
+//        
+//        try {
+//            new Commande("", new Contexte());
+//            new Commande("coucou", new Contexte());
+//            new Commande("$chaine = \"toto\" + $tata", new Contexte());
+//        } catch (NullPointerException e) {
+//            echec();
+//        }
+//    }
+//    
+//    
+//    /**
+//     * Tests unitaires de {@link Commande#executer()}
+//     */
+//    public void testExecuter() {
+//        System.out.println("\tExécution du test de Commande#executer()");
+//        for (Commande aTester : fixture) {
+//            assertFalse(aTester.executer());
+//        }
+//    }
+//}

src/interpreteurlir/motscles/tests/TestCommandeCharge.java

@@ -0,0 +1,111 @@
+/**
+ * TestCommandeCharge.java                              21 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.motscles.tests;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.motscles.Commande;
+import interpreteurlir.motscles.CommandeCharge;
+import interpreteurlir.motscles.CommandeListe;
+import interpreteurlir.programmes.Programme;
+
+import static info1.outils.glg.Assertions.*;
+
+/** 
+ * Tests unitaires de {@link interpreteurlir.motscles.CommandeCharge}
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class TestCommandeCharge {
+
+    /** Contexte pour tests */
+    private final static Contexte CONTEXTE_TESTS = new Contexte();
+
+    /** Programme global pour tests */
+    private static Programme progGlobal = new Programme();
+
+    /** jeu de test valide */
+    public static final CommandeCharge[] FIXTURE = {
+            new CommandeCharge("F:\\Programmation\\WorkspaceInterpreteurLIR"
+                               + "\\outilTest\\dossierFichier\\"
+                               + "lefichier1.lir", CONTEXTE_TESTS),
+            new CommandeCharge("dossierFichier\\lefichier2.lir",
+                               CONTEXTE_TESTS),
+            new CommandeCharge("dossierFichier\\lefichier3.lir",
+                               CONTEXTE_TESTS),
+            new CommandeCharge("dossierFichier\\test\\lefichier4.lir",
+                               CONTEXTE_TESTS),
+            new CommandeCharge("dossierFichier\\test\\test2\\lefichier5.lir",
+                               CONTEXTE_TESTS),
+            new CommandeCharge("     dossierFichier\\lefichier6.lir     ",
+                               CONTEXTE_TESTS),
+            new CommandeCharge("dossierFichier\\test\\test2\\..\\lefichier7.lir",
+                    CONTEXTE_TESTS)
+    };
+
+    /**
+     * Tests unitaires de
+     * {@link CommandeCharge#CommandeCharge(String, Contexte)}
+     */
+    public static void testCommandeCharge() {
+
+        final String[] INVALIDE = {
+                null,
+                "    ",
+                "",
+                "lefichier",
+                "dossier\\      lefichier",
+                "dossier        \\lefichier",
+        };
+
+        for (int i = 0; i < INVALIDE.length ; i++) {
+            try {
+                new CommandeCharge(INVALIDE[i], CONTEXTE_TESTS);
+                echec();
+            } catch (InterpreteurException | NullPointerException lancee) {
+                // Test OK
+            }
+        }
+    }
+    
+    /**
+     * Tests unitaires de
+     * {@link CommandeCharge#executer()}
+     */
+    public static void testExecuter() {
+        
+        Commande.referencerProgramme(progGlobal);
+        
+        final CommandeCharge[] ERREUR = {
+                new CommandeCharge("dossierFichier\\erreur1.lir",
+                                   CONTEXTE_TESTS),
+                new CommandeCharge("dossierFichier\\erreur2.lir",
+                                   CONTEXTE_TESTS)
+        };
+        
+        final int NB_TESTS = FIXTURE.length;
+        System.out.println("\nTest valides de CommandeCharge#executer():");
+        for (int i = 0; i < NB_TESTS ; i++) {
+            System.out.println("Test " + (i+1) + '\\' + NB_TESTS + ":");
+            FIXTURE[i].executer();
+            new CommandeListe("", CONTEXTE_TESTS).executer();
+        }
+        
+        System.out.println("\nTest invalides de CommandeCharge#executer():");
+        for(int i = 0; i < ERREUR.length ; i++) {
+            try {
+                ERREUR[i].executer();
+                echec();
+            } catch (InterpreteurException lancee) {
+                // Test OK
+                new CommandeListe("", CONTEXTE_TESTS).executer();
+            }
+        }
+    }
+
+}

src/interpreteurlir/motscles/tests/TestCommandeDebut.java

@@ -8,7 +8,9 @@ import static info1.outils.glg.Assertions.*;
 
 import interpreteurlir.InterpreteurException;
 import interpreteurlir.Contexte;
+import interpreteurlir.motscles.Commande;
 import interpreteurlir.motscles.CommandeDebut;
+import interpreteurlir.programmes.Programme;
 
 /**
  * Tests unitaires de {@link interpreteurlir.motscles.CommandeDebut}
@@ -59,6 +61,7 @@ public class TestCommandeDebut {
      * Tests unitaires de {@link CommandeDebut#executer()}
      */
     public void testExecuter() {
+        Commande.referencerProgramme(new Programme());
         System.out.println("\tExécution du test de CommandeDebut#executer()");
         for (CommandeDebut cmd : fixture) {
             assertFalse(cmd.executer());

src/interpreteurlir/motscles/tests/TestCommandeEfface.java

@@ -54,14 +54,14 @@ public class TestCommandeEfface {
             "\'a\' : 99"
         };
         
-        System.out.println("Exécution du test de CommandeEfface"
+        System.out.println("\tExécution du test de CommandeEfface"
                            + "(String, Contexte)");
         for (String aTester : INVALIDES) {
             try {
                 new CommandeEfface(aTester, CONTEXTE_TESTS);
                 echec();
             } catch (InterpreteurException e) {
-                // TODO: handle exception
+               // test OK
             }
         }
     }
@@ -69,7 +69,7 @@ public class TestCommandeEfface {
     /** Test de executer() */
     public static void testExecuter() {
         
-        System.out.println("Exécution du test d'executer()\nTest visuel :");
+        System.out.println("\tExécution du test d'executer()\nTest visuel :");
         Commande.referencerProgramme(PGM_TESTS);
         PGM_TESTS.ajouterLigne(new Etiquette(10), 
                 new InstructionAffiche("Bonjour", CONTEXTE_TESTS));

src/interpreteurlir/motscles/tests/TestCommandeFin.java

@@ -20,11 +20,6 @@ import interpreteurlir.motscles.CommandeFin;
  */
 public class TestCommandeFin {
     
-    /** Jeux d'essais de Commande valides pour les tests */
-    private CommandeFin[] fixture = { 
-            new CommandeFin("", new Contexte()),
-    };
-    
     /**
      * Tests unitaires de {@link CommandeFin#CommandeFin(String, Contexte)}
      */
@@ -61,7 +56,6 @@ public class TestCommandeFin {
         System.out.println("\tLe programme doit s'éteindre en affichant un "
                            + "message d'aurevoir :");
         System.out.println("Test exécuter désactiver");
-//        fixture[0].executer();
-        echec();
+        //fixture[0].executer();
     }
 }

src/interpreteurlir/motscles/tests/TestCommandeLance.java

@@ -8,10 +8,6 @@ import interpreteurlir.Contexte;
 import interpreteurlir.InterpreteurException;
 import interpreteurlir.expressions.Expression;
 import interpreteurlir.motscles.CommandeLance;
-import interpreteurlir.motscles.instructions.Instruction;
-import interpreteurlir.motscles.instructions.InstructionVar;
-import interpreteurlir.programmes.Etiquette;
-import interpreteurlir.programmes.Programme;
 
 import static info1.outils.glg.Assertions.*;
 
@@ -29,7 +25,6 @@ import info1.outils.glg.TestException;
 public class TestCommandeLance {
     
     private Contexte contexteTest = new Contexte();
-    private Programme programmeTest = new Programme();
     
     private final CommandeLance[] FIXTURE = {
         new CommandeLance("", contexteTest),
@@ -49,36 +44,6 @@ public class TestCommandeLance {
         "40"
     };    
 
-    private final Etiquette[] JEU_ETIQUETTES = {
-            new Etiquette(1),
-            new Etiquette(10),
-            new Etiquette(13),
-            new Etiquette(25),
-            new Etiquette(31),
-            new Etiquette(40),
-            new Etiquette(78),
-            new Etiquette(89)
-    };
-    
-    private final Instruction[] JEU_INSTRUCTIONS = {
-            new InstructionVar("$res = \"1 \"", contexteTest),
-            new InstructionVar("$res = $res + \"10 \"", contexteTest),
-            new InstructionVar("$res = $res + \"13 \"", contexteTest),
-            new InstructionVar("$res = $res + \"25 \"", contexteTest),
-            new InstructionVar("$res = $res + \"31 \"", contexteTest),
-            new InstructionVar("$res = $res + \"40 \"", contexteTest),
-            new InstructionVar("$res = $res + \"78 \"", contexteTest),
-            new InstructionVar("$res = $res + \"89 \"", contexteTest)
-    };
-    
-    private void ecrireProgrammeTest() {
-        for (int i = 0 ; i < JEU_ETIQUETTES.length ; i++) {
-            programmeTest.ajouterLigne(JEU_ETIQUETTES[i], 
-                                       JEU_INSTRUCTIONS[i]);
-        }
-    }
-    
-
     /** 
      * Test unitaire de 
      * {@link CommandeLance#CommandeLance(String, interpreteurlir.Contexte)}
@@ -95,6 +60,9 @@ public class TestCommandeLance {
         
         Expression.referencerContexte(contexteTest);
         
+        System.out.println("\tExécution du test de "
+                           + "CommandeLance#CommandeLance(String, Contexte)");
+        
         for (int i = 0; i < ARGS_INVALIDES.length; i++) {
             try {
                 new CommandeLance(ARGS_INVALIDES[i], contexteTest);
@@ -122,6 +90,7 @@ public class TestCommandeLance {
         //ecrireProgrammeTest();
         Expression.referencerContexte(contexteTest);
         
+        System.out.println("\tExécution du test de CommandeLance#executer()");
         for (int i = 0 ; i < FIXTURE.length ; i++) {
             try {
                 FIXTURE[i].executer();

src/interpreteurlir/motscles/tests/TestCommandeListe.java

@@ -91,6 +91,9 @@ public class TestCommandeListe {
             "1:100000"
         };
         
+        System.out.println("\tExécution du test de "
+                + "CommandeListe#CommandeListe(String, Contexte)");
+        
         for (int i = 0; i < ARGS_INVALIDES.length; i++) {
             try {
                 new CommandeListe(ARGS_INVALIDES[i], contexteTest);
@@ -130,6 +133,9 @@ public class TestCommandeListe {
         Commande.referencerProgramme(programmeTest);
         Expression.referencerContexte(contexteTest);
         
+        System.out.println("\tExécution du test de "
+                           + "CommandeListe#executer()");
+        
         for (int i = 0 ; i < FIXTURE.length ; i++) {
             try {
                 FIXTURE[i].executer();

src/interpreteurlir/motscles/tests/TestCommandeSauve.java

@@ -0,0 +1,176 @@
+/**
+ * TestCommandeSauve.java                              21 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.motscles.tests;
+
+import static info1.outils.glg.Assertions.*;
+
+import interpreteurlir.motscles.Commande;
+import interpreteurlir.motscles.CommandeSauve;
+import interpreteurlir.programmes.Programme;
+import interpreteurlir.Contexte;
+import interpreteurlir.ExecutionException;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.tests.ProgrammeDeTest;
+
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.InputStreamReader;
+
+/**
+ * Tests unitaires de {@link CommandeSauve}
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class TestCommandeSauve {
+    
+    /** contexte pour les tests */
+    private Contexte contexte = new Contexte();
+    
+    /** Programme pour les tests */
+    private Programme progGlobal = new Programme();
+    
+    /** Jeu de donnée de commandeSauve valides pour les tests  */
+    private CommandeSauve[] fixture = {
+        /* chemin valide */
+        new CommandeSauve("monProgramme.lir", contexte),
+        new CommandeSauve("programmationLIR\\monProgramme.lir", contexte),
+        new CommandeSauve("D:\\testInterpreteurLIR\\test1.lir", contexte),
+        new CommandeSauve("  D:\\testInterpreteurLIR\\test2.lir\t", contexte),
+        
+        /* chemin invalide à l'exécution*/
+        new CommandeSauve("\\\\monProgramme.lir", contexte),
+        new CommandeSauve("monPro//??!gr<>amme.lir", contexte),
+        /* chemin inexistant */
+        new CommandeSauve("D:\\testInterpreteurLIR\\dossierNonCree\\test1.lir", 
+                          contexte),
+        /* lecteur inexistant */
+        new CommandeSauve("X:\\testInterpreteurLIR\\test1.lir", contexte),    
+    };
+
+    /**
+     * Tests unitaires de {@link CommandeSauve#CommandeSauve(String, Contexte)}
+     */
+    public void testCommandeSauveStringContexte() {
+        final String[] ARGS_INVALIDES = {
+             "",
+             "   \t  ",
+             "D:\\utilisateurs\\defaut\\bureau\\",
+             "D:\\utilisateurs\\defaut\\bureau\\monProgramme.txt",
+             "D:\\utilisateurs\\defaut\\bureau\\monProgramme",
+             "nouveau dossier\\monProgramme.java",
+             "nouveau dossier\\monProgramme",
+             "monProgramme.class",
+             "monProgramme"
+        };
+        
+        System.out.println("\tExécution du test de "
+                           + "CommandeSauve#CommandeSauve(String, Contexte)");
+        
+        for (String aTester : ARGS_INVALIDES) {
+            try {
+                new CommandeSauve(aTester, contexte);
+                echec();
+            } catch (InterpreteurException e) {
+                // test ok
+            }
+        }
+        
+        try {
+            /* chemin valide */
+            new CommandeSauve("monProgramme.lir", contexte);
+            new CommandeSauve("programmationLIR\\monProgramme.lir", contexte);
+            new CommandeSauve("D:\\testInterpreteurLIR\\test1.lir", contexte);
+            new CommandeSauve("  D:\\testInterpreteurLIR\\test2.lir\t",
+                              contexte);
+            /* chemin invalide à l'exécution*/
+            new CommandeSauve("\\\\monProgramme.lir", contexte);
+            new CommandeSauve("monPro//??!gr<>amme.lir", contexte);
+            /* chemin inexistant */
+            new CommandeSauve("D:\\testInterpreteurLIR\\dossierNonCree\\"
+                              + "test1.lir", contexte);
+            /* lecteur inexistant */
+            new CommandeSauve("X:\\testInterpreteurLIR\\test1.lir", contexte);
+        } catch (InterpreteurException e) {
+            echec();
+        }
+        
+    }
+    
+    /**
+     * Tests unitaires de {@link CommandeSauve#executer()}
+     */
+    public void testExecuter() {
+        final int INDEX_INVALIDES = 4;
+        
+        Commande.referencerProgramme(progGlobal);
+        System.out.println("\tExécution du test de CommandeSauve#executer()");
+        
+        /* Tests des chemins invalides */
+        for (int index = INDEX_INVALIDES ; index < fixture.length ; index++) {
+            try {
+                fixture[index].executer();
+                echec();
+            } catch (ExecutionException lancee) {
+                // test OK
+            }
+        }
+        
+
+        try {
+            assertFalse(fixture[0].executer());
+            assertEquivalence(progGlobal.toString(), 
+                              lireFichier("monProgramme.lir"));
+            assertFalse(fixture[2].executer());
+            assertEquivalence(progGlobal.toString(), 
+                    lireFichier("D:\\testInterpreteurLIR\\test1.lir"));
+            
+            ProgrammeDeTest.genererProgramme(progGlobal, contexte);
+            
+            assertFalse(fixture[1].executer());
+            assertEquivalence(progGlobal.toString(), 
+                    lireFichier("programmationLIR\\monProgramme.lir"));
+            
+            assertFalse(fixture[3].executer());
+            assertEquivalence(progGlobal.toString(), 
+                    lireFichier("D:\\testInterpreteurLIR\\test2.lir"));
+            
+        } catch (ExecutionException lancee) {
+            echec();
+        }
+
+    }
+
+    /**
+     * Lit un fichier et retourne le contenu entier du fichier
+     * @param cheminFichier chemin du fichier à lire
+     * @return contenu du fichier
+     */
+    private static String lireFichier(String cheminFichier) {
+        BufferedReader aTester;
+          StringBuilder contenu = new StringBuilder("");
+          
+          aTester = null;
+          try {
+              aTester = new BufferedReader(
+                           new InputStreamReader(
+                               new FileInputStream(cheminFichier)));
+              String ligneLue;
+              do {
+                  ligneLue = aTester.readLine();
+                  if (ligneLue != null) {
+                      contenu.append(ligneLue).append("\n");
+                  }
+              } while (ligneLue != null);
+              aTester.close();
+          } catch (Exception e) {
+              echec();
+          }
+          
+          return contenu.toString();
+    }
+}

src/interpreteurlir/programmes/Programme.java

@@ -30,7 +30,7 @@ import static interpreteurlir.programmes.Etiquette.VALEUR_ETIQUETTE_MIN;
 public class Programme {
     
     private static final String ERREUR_INTERVALLE = "erreur dans l'intervalle "
-                                                    + "d'étiquettes. "; 
+                                                    + "d'étiquettes"; 
     
     /** Pile LIFO pour la gestion des étiquettes */
     private Stack<Etiquette> compteurOrdinnal;
@@ -42,15 +42,13 @@ public class Programme {
     
     /** 
      * Initialisation de ce programme sans lignes de code
-     * <p>
-     * 
      */
     public Programme() {
         super();
+        
         lignesCode = new TreeMap<Etiquette, Instruction>();
         enExecution = false;
         compteurOrdinnal = new Stack<Etiquette>();
-        
     }
 
     /** 
@@ -91,11 +89,8 @@ public class Programme {
     @Override
     public String toString() {
         
-        Object[] tableauEtiquette 
-                = lignesCode.keySet().toArray();
-        
-        Object[] tableauInstruction
-                = lignesCode.values().toArray();
+        Object[] tableauEtiquette = lignesCode.keySet().toArray();
+        Object[] tableauInstruction = lignesCode.values().toArray();
         
         StringBuilder aAfficher = new StringBuilder("");
         
@@ -150,8 +145,7 @@ public class Programme {
             }
         } while (lignesRestantes);
         
-        return aAfficher.toString().equals("") 
-               ? "Aucune ligne de code dans cet intervalle.\n"
+        return aAfficher.toString().equals("") ? "aucune ligne à afficher\n"
                                                : aAfficher.toString();
     }
     
@@ -236,8 +230,18 @@ public class Programme {
     /**
      * Change le compteur ordinal avec l'étiquette argument
      * @param destination étiquette où continuer l'exécution
+     * @throws ExecutionException si aucune instruction dans le programme
+     *                            n'a comme étiquette destination
      */
     public void vaen(Etiquette destination) {
+        final String ERR_ETIQUETTE = "vaen impossible car l'étiquette " 
+                                     + destination 
+                                     + " ne correspond à aucune instruction";
+        if (!lignesCode.containsKey(destination)) {
+            throw new ExecutionException(ERR_ETIQUETTE);
+        }
+        // else
+        
         if (!compteurOrdinnal.isEmpty()) {
             compteurOrdinnal.pop();
         }
@@ -258,12 +262,11 @@ public class Programme {
     /** 
      * Retour d'une procédure en dépilant l'étiquette de départ dans
      * le compteurOrdinal 
-     * @param depart étiquette du début de la procédure
      * @throws ExecutionException lorsque retourProcedure vide le 
      *                            compteurOrdinnal
      */
     public void retourProcedure() {
-        final String ERREUR_RETOUR = "erreur retour nécessite un appel de "
+        final String ERREUR_RETOUR = "retour nécessite un appel de "
                                      + "procédure au préalable";
         try {
             compteurOrdinnal.pop();

src/interpreteurlir/programmes/tests/TestProgramme.java

@@ -10,6 +10,9 @@ import interpreteurlir.ExecutionException;
 import interpreteurlir.InterpreteurException;
 import interpreteurlir.expressions.Expression;
 import interpreteurlir.motscles.instructions.*;
+import interpreteurlir.motscles.instructions.tests.TestInstructionStop;
+import interpreteurlir.motscles.instructions.tests.TestInstructionVaen;
+
 import static info1.outils.glg.Assertions.*;
 
 /** 
@@ -156,7 +159,7 @@ public class TestProgramme {
     public void testListeBornee() {
         
         final String[] TEXTES_ATTENDUS = {
-            "Aucune ligne de code dans cet intervalle.\n",
+            "aucune ligne à afficher\n",
             "1 var $toto = \"toto\"\n"
                     + "5 var $agreuagreu = \"agreu\"\n"
                     + "10 var tata = 0 + 0\n"
@@ -202,13 +205,6 @@ public class TestProgramme {
      */
     public void testEffacer() {
         
-//        final Etiquette[][] BORNES = {
-//                { new Etiquette(6), new Etiquette(6) },
-//                { new Etiquette(1), new Etiquette(90) },
-//                { new Etiquette(31), new Etiquette(39) },
-//                { new Etiquette(9), new Etiquette(41) }
-//        };
-        
         final String[] TEXTES_ATTENDUS = {
             "1 var $toto = \"toto\"\n"
                     + "5 var $agreuagreu = \"agreu\"\n"
@@ -256,13 +252,11 @@ public class TestProgramme {
     
     /** 
      * Test unitaire de {@link Programme#stop()}
+     * @see TestInstructionStop#testExecuter()
      */
     public void testStop() {
-        //TODO écrire les tests lorsque l'instruction stop sera définie
-        
-        System.out.println("\tExécution du test de stop() : ");
-        
-        echec();
+        System.out.println("\tExécution du test de Programme#stop() "
+                + ": voir TestInstructionStop#testExecuter()");
     }
     
     /** 
@@ -271,7 +265,7 @@ public class TestProgramme {
     public void testLancerEtiquette() {
         final Etiquette[] ETIQUETTES_DEPART = {
             new Etiquette(1),
-            new Etiquette(9),
+            new Etiquette(10),
             new Etiquette(25),
             new Etiquette(90)
         };
@@ -297,7 +291,6 @@ public class TestProgramme {
      * Test unitaire de {@link Programme#lancer()}
      */
     public void testLancer() {
-
         Expression.referencerContexte(contexteTest);
         contexteTest.raz();
         
@@ -314,14 +307,35 @@ public class TestProgramme {
      * Test unitaire de {@link Programme#appelProcedure(Etiquette)}
      */
     public void testAppelProcedure() {
-        //TODO écrire les tests
         
         System.out.println("\tExécution du test de appelProcedure(Etiquette) "
                            + ": ");
         
+        /* Cas Valides */
+        try {
+            /* Simulation du lancement du programme */
+            programmeTest.appelProcedure(new Etiquette(1));
+            /* Lancement de 2 procédures */
+            programmeTest.appelProcedure(new Etiquette(100));
+            programmeTest.appelProcedure(new Etiquette(50));
+        } catch (InterpreteurException lancee) {
             echec();
         }
         
+        /* Cas Invalides */
+        try {
+            /* Simulation du lancement du programme */
+            programmeTest.appelProcedure(new Etiquette(1));
+            
+            /* Lancement de 2 procédures */
+            programmeTest.appelProcedure(new Etiquette(-30));
+            programmeTest.appelProcedure(new Etiquette(10000000));
+            echec();
+        } catch (InterpreteurException lancee) {
+            /* Test OK */
+        }
+    }
+    
    /**
     * Test unitaire de {@link Programme#retourProcedure()}
     */
@@ -352,13 +366,11 @@ public class TestProgramme {
    
    /** 
     * Test unitaire de {@link Programme#vaen(Etiquette)}
+    * @see TestInstructionVaen#testExecuter()
     */
    public void testVaen() {
-       //TODO écrire les tests
-       
        System.out.println("\tExécution du test de vaen(Etiquette) "
-                          + ": ");
+                          + ": voir TestInstructionVaen#testExecuter()");
       
-       echec();
    }
 }

src/interpreteurlir/tests/ProgrammeDeTest.java

@@ -0,0 +1,69 @@
+/**
+ * ProgrammeDeTest.java                              18 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.tests;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.motscles.instructions.*;
+import interpreteurlir.programmes.Etiquette;
+import interpreteurlir.programmes.Programme;
+
+/**
+ * Permet de générer un programme pour les tests contenant plusieurs lignes.
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class ProgrammeDeTest {
+
+    /**
+     * Génère en ajoutant au programme des lignes
+     * pour les tests
+     * @param aGenerer programme auquel est ajouté les lignes
+     * @param contexte contexte pour les instructions
+     */
+    public static void genererProgramme(Programme aGenerer, Contexte contexte) {
+        Object[][] lignes = {
+                {new Etiquette(10), new InstructionAffiche("\"Bienvenue dans le programme\"", contexte)},
+                {new Etiquette(20), new InstructionAffiche("", contexte)},  
+                {new Etiquette(30), new InstructionVar("instant = 2021", contexte)},  
+                {new Etiquette(40), new InstructionProcedure("500", contexte)},
+                {new Etiquette(50), new InstructionVar("$message = \"Vous êtes \" + $prenom", contexte)},  
+                {new Etiquette(60), new InstructionVar("$message = $message+ \" \"", contexte)},
+                {new Etiquette(65), new InstructionVar("$message = $message+ $nom", contexte)}, 
+                {new Etiquette(70), new InstructionAffiche("$message", contexte)}, 
+                {new Etiquette(80), new InstructionAffiche("", contexte)}, 
+                {new Etiquette(90), new InstructionAffiche("\"age : \"", contexte)},
+                {new Etiquette(100), new InstructionAffiche("age", contexte)},
+                {new Etiquette(110), new InstructionAffiche("\" ans\"", contexte)},
+                {new Etiquette(120), new InstructionVaen("130", contexte)},
+                {new Etiquette(124), new InstructionAffiche("", contexte)},
+                {new Etiquette(125), new InstructionAffiche("\"erreur vaen si affiché\"", contexte)},
+                {new Etiquette(150), new InstructionAffiche("", contexte)}, 
+                {new Etiquette(200), new InstructionAffiche("\"Merci d'avoir utilisé ce programme !\"", contexte)},  
+                {new Etiquette(400), new InstructionStop("", contexte)},
+                // procedure saisie
+                {new Etiquette(500), new InstructionAffiche("\"Saisissez votre nom : \"", contexte)},  
+                {new Etiquette(510), new InstructionEntre("$nom", contexte)},  
+                {new Etiquette(520), new InstructionAffiche("\"Saisissez votre prénom : \"", contexte)},  
+                {new Etiquette(530), new InstructionEntre("$prenom", contexte)},  
+                {new Etiquette(540), new InstructionAffiche("\"Saisissez votre année de naissance (entier) : \"", contexte)},  
+                {new Etiquette(550), new InstructionEntre("naissance", contexte)}, 
+                {new Etiquette(560), new InstructionProcedure("1000", contexte)},  
+                {new Etiquette(570), new InstructionRetour("", contexte)},  
+                // procedure calcul age
+                {new Etiquette(1000), new InstructionVar("age = instant - naissance", contexte)},
+                {new Etiquette(1010), new InstructionRetour("", contexte)},  
+                
+        };
+        
+        for (int index = 0 ; index < lignes.length ; index++) {
+            aGenerer.ajouterLigne((Etiquette)lignes[index][0], 
+                                  (Instruction)lignes[index][1]);
+        }
+    }
+
+}

src/interpreteurlir/tests/TestContexte.java

@@ -86,7 +86,6 @@ public class TestContexte {
                 "aucune variable n'est définie\n",
                 "aucune variable n'est définie\n",
                 "aucune variable n'est définie\n",
-                // TODO refaire quand totalement fonctionnel
         };
         
         System.out.println("\tExécution du test de Contexte#toString()");
@@ -136,7 +135,8 @@ public class TestContexte {
         assertEquivalence(fixture[0].lireValeurVariable(
                 new IdentificateurChaine("$chaine")).getValeur(), "");
         assertEquivalence(fixture[0].lireValeurVariable(
-                new IdentificateurEntier("entier")).getValeur(), Integer.valueOf(0));
+                new IdentificateurEntier("entier")).getValeur(), 
+                                         Integer.valueOf(0));
         
         // lire valeur par défaut dans contexte non vide
         fixture[1].ajouterVariable(new IdentificateurChaine("$zoro"),