diff --git a/src/interpreteurlir/Analyseur.java b/src/interpreteurlir/Analyseur.java
index 67410fd..fb2c05b 100644
--- a/src/interpreteurlir/Analyseur.java
+++ b/src/interpreteurlir/Analyseur.java
@@ -9,6 +9,8 @@ import java.util.Scanner;
 
 import interpreteurlir.expressions.Expression;
 import interpreteurlir.motscles.Commande;
+import interpreteurlir.motscles.instructions.Instruction;
+import interpreteurlir.programmes.*;
 
 /**
  * Analyseur de l'entrée standard du programme interpréteur LIR.
@@ -34,6 +36,9 @@ public class Analyseur {
     
     /** contexte de cet analyseur */
     private Contexte contexteGlobal;
+    
+    /** programme de cet analyseur */
+    private Programme programme;
 
     /**
      * Initialise un analyseur ayant son propre contexte.
@@ -43,6 +48,8 @@ public class Analyseur {
         entree = new Scanner(System.in);
         contexteGlobal = new Contexte();
         Expression.referencerContexte(contexteGlobal);
+        programme = new Programme();
+        Commande.referencerProgramme(programme);
     }
 
     /**
@@ -51,18 +58,72 @@ public class Analyseur {
      */
     public void mainLoop() {
         String ligneSaisie;
+        String[] decoupage;
+        String motCle;
+        String arguments;
+        String texteEtiquette;
         for (;;) {
+            texteEtiquette = null;
+            
             System.out.print(INVITE);
             ligneSaisie = entree.nextLine().trim();
             
-            String[] decoupage = ligneSaisie.split(" ", 2);
-            String motCle = decoupage.length >= 1 ? decoupage[0] : "";
-            String arguments = decoupage.length >= 2 ? decoupage[1] : "";
+            /* Instruction avec étiquette */
+            if (!ligneSaisie.isBlank() 
+                    && Character.isDigit(ligneSaisie.charAt(0))) {
+                decoupage = ligneSaisie.split(" ", 2);
+                texteEtiquette = decoupage.length >= 1 ? decoupage[0] : "";
+                ligneSaisie = decoupage.length >= 2 ? decoupage[1] : "";
+            }
             
-            executerCommande(motCle, arguments.trim());
+            decoupage = ligneSaisie.split(" ", 2);
+            motCle = decoupage.length >= 1 ? decoupage[0] : "";
+            arguments = decoupage.length >= 2 ? decoupage[1] : "";
+            
+            if (texteEtiquette == null) {
+                executerCommande(motCle, arguments.trim());
+            } else {
+                editerProgramme(texteEtiquette, motCle, arguments.trim());
+            }
         }
     }
     
+    /**
+     * Ajoute une ligne de code (étiquette associée à une instruction) 
+     * au programme chargé.
+     * @param texteEtiquette représentation texte de l'étiquette
+     * @param motCle mot clé de l'instruction
+     * @param arguments reste de la ligne saisie après le mot clé
+     */
+    private void editerProgramme(String texteEtiquette, String motCle, 
+                                 String arguments) {
+        Class<?> aAjouter;
+        try {
+            aAjouter = rechercheInstruction(motCle);
+            
+            Class<?> classeArg = String.class;
+            Class<?> classeContexte = Contexte.class;
+            Instruction inst = (Instruction)aAjouter
+                                   .getConstructor(classeArg, classeContexte)
+                                   .newInstance(arguments, contexteGlobal);
+            
+            Etiquette etiquette = new Etiquette(texteEtiquette);
+            
+            programme.ajouterLigne(etiquette, inst);
+            feedback(false);
+            
+        } catch (  InvocationTargetException | IllegalAccessException 
+                 | InstantiationException    | NoSuchMethodException 
+                 | InterpreteurException     | ExecutionException lancee) {
+            
+            System.err.println(NOK_FEEDBACK 
+                    + (lancee.getMessage() != null 
+                       ? lancee.getMessage() 
+                       : lancee.getCause().getMessage()));
+        }
+        
+    }
+
     /**
      * Recherche la commande et exécute cette commande si présente.
      * Affiche un feedback si la commande ne s'en occupe pas ou erreur.
@@ -84,7 +145,7 @@ public class Analyseur {
             feedback(cmd.executer());
         } catch (  InvocationTargetException | IllegalAccessException 
                  | InstantiationException    | NoSuchMethodException 
-                 | InterpreteurException lancee) {
+                 | InterpreteurException     | ExecutionException lancee) {
             
             System.err.println(NOK_FEEDBACK 
                     + (lancee.getMessage() != null 
@@ -127,6 +188,8 @@ public class Analyseur {
         
         if (motCle == null || motCle.isBlank()) {
             throw new InterpreteurException(ERREUR_VIDE);
+        } else if (!motCle.equals(motCle.toLowerCase())) {
+            throw new InterpreteurException(ERREUR_INCONNU);
         }
         
         motCle =   (Character.toUpperCase(motCle.charAt(0))) 
@@ -145,6 +208,42 @@ public class Analyseur {
  
         return aChercher;
     }
+    
+    /**
+     * Recherche l'instruction correspondant au mot clé.
+     * <ul><li>Les instructions doivent être 
+     *         dans le package interpreteurlir.motscles.instructions</li>
+     * <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) {
+        final String ERREUR_VIDE = "ligne vide";
+        final String ERREUR_INCONNU = "mot clé inconnu";
+        final String CLASS_PATH_INST = 
+                "interpreteurlir.motscles.instructions.Instruction";
+        
+        if (motCle == null || motCle.isBlank()) {
+            throw new InterpreteurException(ERREUR_VIDE);
+        } else if (!motCle.equals(motCle.toLowerCase())) {
+            throw new InterpreteurException(ERREUR_INCONNU);
+        }
+        
+        motCle =   (Character.toUpperCase(motCle.charAt(0))) 
+                 + (motCle.length() > 1 ? motCle.substring(1) : "");
+        
+        Class<?> aChercher;
+        try {
+            aChercher = Class.forName(CLASS_PATH_INST + motCle);
+        } catch(ClassNotFoundException | NoClassDefFoundError nonCmd) {
+            throw new InterpreteurException(ERREUR_INCONNU);
+        }
+ 
+        return aChercher;
+    }
 
     /**
      * Lancement de l'interpréteur LIR.
diff --git a/src/interpreteurlir/donnees/Identificateur.java b/src/interpreteurlir/donnees/Identificateur.java
index a6f789b..a1a4103 100644
--- a/src/interpreteurlir/donnees/Identificateur.java
+++ b/src/interpreteurlir/donnees/Identificateur.java
@@ -17,97 +17,75 @@ import interpreteurlir.InterpreteurException;
  */
 public class Identificateur /* extends Variable */
 implements Comparable<Identificateur> {
-    
+
     /** Longueur maximale d'un identificateur (ne prend pas en compte le $) */
-        public static final int LONGUEUR_MAX = 24;
-        
-        /** Nom identificateur */
+    public static final int LONGUEUR_MAX = 25;
+
+    /** Nom identificateur */
     private String nom;
-        
+
     /**
      * Instantiation de l'identificateur
      * @param identificateur
      */
-        public Identificateur(String identificateur) {
-                super();
-                if(!isIdentificateur(identificateur)) {
-                    throw new InterpreteurException(identificateur
-                                                       + " n'est pas un identificateur");
-                }
-                
-                nom = identificateur;
+    public Identificateur(String identificateur) {
+        super();
+        identificateur = identificateur.trim();
+        if(!isIdentificateur(identificateur)) {
+            throw new InterpreteurException(identificateur
+                    + " n'est pas un identificateur");
         }
-        
-        /**
-         * Prédicat qui vérifie si une chaîne correspond à un identificateur
-         * <ul>
-         *     <li>Longueur comprise entre 1 et 24 caractères</li>
-         *     <li>N'est pas une chaîne vide</li>
-         *     <li>N'est pas null</li>
-         * </ul>
-         * @param aComparer
-         * @return true si le prédicat est vérifié
-         *         false sinon
-         */
-        public static boolean isIdentificateur(String aComparer) {
-                return aComparer != null
-                       && aComparer.length() > 0
-                       && !removeDollar(aComparer).isBlank()
-                       && removeDollar(aComparer).length() <= LONGUEUR_MAX
-                       && isAlphanumerique(removeDollar(aComparer));
-        }
-        
-        /**
-         * Supprime le caractère $ si il est présent en premier dans la chaîne
-         * @param chaine a modifier
-         * @return la chaîne modifiée
-         */
-        public static String removeDollar(String chaine) {
-            if(chaine.charAt(0) == '$') return chaine.substring(1);
-            return chaine;
-        }
-        
-        /**
-         * Prédicat testant si une chaîne est composée de chiffre ou de lettres
-         * @param aTester chaîne a tester
-         * @return true si le prédicat est vérifié
-         *         false sinon
-         */
-        public static boolean isAlphanumerique(String aTester) {
-                int index;
-                
-                for (index = 0 ;
-                         index < aTester.length()
-                         && (isLettre(aTester.charAt(index))
-                                 || isChiffre(aTester.charAt(index)));
-                         index++)
-                ;    // Corps vide
-                
-                return index >= aTester.length();
-        }
-        
-        /**
-         * Prédicat attestant si un caractère est une lettre
-         * @param aTester caractère a tester
-         * @return true si le prédicat est vérifié
-         *         false sinon
-         */
-        public static boolean isLettre(char aTester) {
-                return 'a' <= aTester && aTester <= 'z'
-                           || 'A' <= aTester && aTester <= 'Z';
-        }
-        
-        /**
-         * Prédicat attestant si un caractère est un chiffre
-         * @param aTester caractère a tester
-         * @return true si le prédicat est vérifié
-         *         false sinon
-         */
-        public static boolean isChiffre(char aTester) {
-                return '0' <= aTester && aTester <= '9';
-        }
-        
-        /**
+
+        nom = identificateur;
+    }
+
+    /**
+     * Prédicat qui vérifie si une chaîne correspond à un identificateur
+     * <ul>
+     *     <li>Longueur comprise entre 1 et 24 caractères</li>
+     *     <li>N'est pas une chaîne vide</li>
+     *     <li>N'est pas null</li>
+     * </ul>
+     * @param aTester
+     * @return true si le prédicat est vérifié
+     *         false sinon
+     */
+    public static boolean isIdentificateur(String aTester) {
+        return aTester != null
+                && aTester.length() > 0
+                && !removeDollar(aTester).isBlank()
+                && removeDollar(aTester).length() <= LONGUEUR_MAX
+                && isAlphanumerique(removeDollar(aTester));
+    }
+
+    /**
+     * Supprime le caractère $ si il est présent en premier dans la chaîne
+     * @param chaine a modifier
+     * @return la chaîne modifiée
+     */
+    public static String removeDollar(String chaine) {
+        if(chaine.charAt(0) == '$') return chaine.substring(1);
+        return chaine;
+    }
+
+    /**
+     * Prédicat testant si une chaîne est composée de chiffre ou de lettres
+     * @param aTester chaîne a tester
+     * @return true si le prédicat est vérifié
+     *         false sinon
+     */
+    public static boolean isAlphanumerique(String aTester) {
+        int index;
+        for (index = 0 ;
+            index < aTester.length()
+            && Character.isLetterOrDigit(aTester.charAt(index)) ;
+            index++)
+            ;    // Corps vide
+
+            return index >= aTester.length();
+    }
+
+    /**
      * @return la valeur de nom
      */
     public String getNom() {
@@ -125,6 +103,4 @@ implements Comparable<Identificateur> {
     public int compareTo(Identificateur aComparer) {
         return nom.compareTo(aComparer.nom);
     }
-    
-    
 }
diff --git a/src/interpreteurlir/donnees/IdentificateurChaine.java b/src/interpreteurlir/donnees/IdentificateurChaine.java
index c824593..0277202 100644
--- a/src/interpreteurlir/donnees/IdentificateurChaine.java
+++ b/src/interpreteurlir/donnees/IdentificateurChaine.java
@@ -19,31 +19,30 @@ import interpreteurlir.InterpreteurException;
 public class IdentificateurChaine extends Identificateur {
 
     /**
-         * Instantiation d'identificateur de chaîne
-         * @param identificateur a instancier
-         * @throws InterpreteurException si l'identificateur est invalide
-         */
-        public IdentificateurChaine(String identificateur) {
-                super(identificateur.trim());
-                
-                identificateur = identificateur.trim();
-                if(!isIdentificateurChaine(identificateur)) {
-                        throw new InterpreteurException(identificateur
-                                                           + " n'est pas un identificateur"
-                                                           + " de chaine");
-                }
+     * Instantiation d'identificateur de chaîne
+     * @param identificateur a instancier
+     * @throws InterpreteurException si l'identificateur est invalide
+     */
+    public IdentificateurChaine(String identificateur) {
+        super(identificateur);
+        identificateur = identificateur.trim();
+        if(!isIdentificateurChaine(identificateur)) {
+           throw new InterpreteurException(identificateur
+                                           + " n'est pas un identificateur"
+                                           + " de chaine");
         }
-        
-        /**
-         * Prédicat attestant la validité de l'identificateur
-         * @param identificateur à tester
-         * @return true si l'identificateur est bien un identificateur d'entier
-         *                 false sinon
-         */
-        private static boolean isIdentificateurChaine(String identificateur) {
+    }
 
-                return identificateur.length() >= 2
-               && identificateur.charAt(0) == '$'
-               && isLettre(identificateur.charAt(1));
-        }
+    /**
+     * Prédicat attestant la validité de l'identificateur
+     * @param identificateur à tester
+     * @return true si l'identificateur est bien un identificateur d'entier
+     *                 false sinon
+     */
+    private static boolean isIdentificateurChaine(String identificateur) {
+
+        return identificateur.length() >= 2
+                && identificateur.charAt(0) == '$'
+                && Character.isLetter(identificateur.charAt(1));
+    }
 }
diff --git a/src/interpreteurlir/donnees/IdentificateurEntier.java b/src/interpreteurlir/donnees/IdentificateurEntier.java
index 7da0f9b..e3e273d 100644
--- a/src/interpreteurlir/donnees/IdentificateurEntier.java
+++ b/src/interpreteurlir/donnees/IdentificateurEntier.java
@@ -9,7 +9,9 @@ package interpreteurlir.donnees;
 import interpreteurlir.InterpreteurException;
 
 /**
- * Identificateur d'entier
+ * Identificateur d'entier utilisé pour instancier des variables du même type.
+ * Un identificateur entier commence par une lettre suivie d'au plus 24
+ * caractère alphanumériques.
  * @author Nicolas Caminade
  * @author Sylvan Courtiol
  * @author Pierre Debas
@@ -18,36 +20,37 @@ import interpreteurlir.InterpreteurException;
  */
 public class IdentificateurEntier extends Identificateur {
 
-        /**
-         * Instantiation d'identificateur d'entier
-         * @param identificateur a instancier
-         * @throws InterpreteurException si l'identificateur est invalide
-         */
-        public IdentificateurEntier(String identificateur) {
-                super(identificateur);
-                
-                if(!isIdentificateurEntier(identificateur)) {
-                        throw new InterpreteurException(identificateur
-                                + " n'est pas un identificateur"
-                                + " d'entier");
-                }
-        }
-        
-        /**
-         * Prédicat attestant la validité de l'identificateur
-         * 
-         * Un identificateur d'entier est valide si
-         * - Il contient au maximum 24 caractères
-         * - Commence obligatoirement par une lettre (majuscule ou minuscule)
-         * - suivie uniquement de lettres (majuscule ou minuscule) ou de chiffres
-         * 
-         * @param identificateur à tester
-         * @return true si l'identificateur est bien un identificateur d'entier
-         *                 false sinon
-         */
-        private static boolean isIdentificateurEntier(String identificateur) {
-        
-                return isLettre(identificateur.charAt(0))
-               && isAlphanumerique(identificateur.substring(1));
+    /**
+     * Instantiation de cet identificateur d'entier avec le nom spécififié 
+     * en argument. Lève une exception si l'identificateur n'est pas
+     * valide.
+     * @param identificateur a instancier
+     * @throws InterpreteurException si l'identificateur est invalide
+     */
+    public IdentificateurEntier(String identificateur) {
+        super(identificateur);
+
+        if(!isIdentificateurEntier(identificateur)) {
+           throw new InterpreteurException(identificateur
+                                           + " n'est pas un identificateur"
+                                           + " d'entier");
         }
+    }
+
+    /**
+     * Prédicat attestant la validité de l'identificateur
+     * 
+     * Un identificateur d'entier est valide si
+     * - Il contient au maximum 24 caractères
+     * - Commence obligatoirement par une lettre (majuscule ou minuscule)
+     * - suivie uniquement de lettres (majuscule ou minuscule) ou de chiffres
+     * 
+     * @param aTester à tester
+     * @return true si l'identificateur est bien un identificateur d'entier
+     *                 false sinon
+     */
+    private static boolean isIdentificateurEntier(String aTester) {
+        return aTester.length() <= 25 && Character.isLetter(aTester.charAt(0))
+            && isAlphanumerique(aTester.substring(1));
+    }
 }
diff --git a/src/interpreteurlir/donnees/Variable.java b/src/interpreteurlir/donnees/Variable.java
index 1d0b5dd..7216469 100644
--- a/src/interpreteurlir/donnees/Variable.java
+++ b/src/interpreteurlir/donnees/Variable.java
@@ -5,6 +5,7 @@
 package interpreteurlir.donnees;
 
 import interpreteurlir.donnees.litteraux.Chaine;
+import interpreteurlir.donnees.litteraux.Entier;
 import interpreteurlir.donnees.litteraux.Litteral;
 import interpreteurlir.InterpreteurException;
 
@@ -38,7 +39,7 @@ public class Variable extends Object implements Comparable<Variable> {
         if (!isVariable(identificateur, valeur)) {
             throw new InterpreteurException("Identificateur '"
                                             + identificateur.toString()
-                                            + "' et type de " 
+                                             + "' et type de " 
                                             + valeur.toString()
                                             + "incompatible.");
         }
@@ -50,7 +51,7 @@ public class Variable extends Object implements Comparable<Variable> {
     
     private static boolean isVariable(Identificateur id, Litteral valeur) {
         return id instanceof IdentificateurChaine && valeur instanceof Chaine
-              /* || id instanceof IdentificateurEntier && valeur instanceof Entier */;
+            || id instanceof IdentificateurEntier && valeur instanceof Entier;
     }
 
 
diff --git a/src/interpreteurlir/donnees/litteraux/Chaine.java b/src/interpreteurlir/donnees/litteraux/Chaine.java
index 2ad3d33..bca64e4 100644
--- a/src/interpreteurlir/donnees/litteraux/Chaine.java
+++ b/src/interpreteurlir/donnees/litteraux/Chaine.java
@@ -20,7 +20,8 @@ public class Chaine extends Litteral {
         public static final int LG_MAX_CHAINE = 70;
         
         /** Erreur chaîne trop longue */
-        private static final String ERREUR_LG_MAX = "Longueur maximale dépassée";
+        private static final String ERREUR_LG_MAX = 
+                "Longueur maximale d'une chaîne dépassée";
         
         /** Erreur constante littéral chaîne invalide */
         private static final String ERREUR_INVALIDE = 
@@ -69,7 +70,6 @@ public class Chaine extends Litteral {
          */
         @Override
         public int compareTo(Litteral autre) {
-                // TODO Auto-generated method stub
                 return this.valeur.toString().compareTo(autre.valeur.toString());
         }
 
diff --git a/src/interpreteurlir/donnees/litteraux/Entier.java b/src/interpreteurlir/donnees/litteraux/Entier.java
index 02863cf..f5fe21d 100644
--- a/src/interpreteurlir/donnees/litteraux/Entier.java
+++ b/src/interpreteurlir/donnees/litteraux/Entier.java
@@ -4,21 +4,86 @@
  */
 package interpreteurlir.donnees.litteraux;
 
+import interpreteurlir.ExecutionException;
+import interpreteurlir.InterpreteurException;
+
 /**
- * BOUCHON
- * @author 
- *
+ * Constante littérale de type entier
+ * 
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
  */
 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;
     
-    /** TODO commenter l'état initial
-     * @param i
+    /** 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
      */
-    public Entier(int i) {
-        super(Integer.valueOf(i));
-        // TODO Auto-generated constructor stub
-        valeur = i;
+    @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 
+     */
+    public Entier(String uneValeur) {
+        if (!isEntier(uneValeur)) {
+            throw new InterpreteurException(uneValeur 
+                                            + " 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();
+        }
+        
+        return false;
+    }
+
+    private static boolean isChiffre(char caractere) {
+        return '0' <= caractere && caractere <= '9';
+    }
+
+    private static boolean isEntier(int entier) {
+        return VALEUR_MIN <= entier && entier <= VALEUR_MAX;
     }
 
     /* non javadoc
@@ -28,7 +93,80 @@ public class Entier extends Litteral {
     public String toString() {
         return valeur.toString();
     }
-    
-    
 
+    @Override
+    public Integer getValeur() {
+        return (Integer) super.valeur;
+    }
+
+    /** 
+     * 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
+     */
+    public int compareTo(Entier autre) {
+        return ((Integer) valeur).compareTo(autre.getValeur());
+    }
+
+    /** 
+     * Somme de deux entiers
+     * @param premier Entier
+     * @param second Entier
+     * @return la somme des deux entiers
+     */
+    public static Entier somme(Entier premier, Entier second) {
+        return new Entier((int) premier.getValeur() + (int) second.getValeur());
+        
+    }
+    
+    /** 
+     * Soustraction de deux entiers
+     * @param premier Entier
+     * @param second Entier
+     * @return le résultat de premier auquel on soustrait second
+     */
+    public static Entier soustrait(Entier premier, Entier second) {
+        return new Entier((int) premier.getValeur() - (int) second.getValeur());
+        
+    }
+    
+    /** 
+     * Multiplication de deux entiers
+     * @param premier Entier
+     * @param second Entier
+     * @return le résultat de premier multiplié par second
+     */
+    public static Entier multiplie(Entier premier, Entier second) {
+        return new Entier((int) premier.getValeur() * (int) second.getValeur());
+    }
+    
+    /** 
+     * Division de deux entiers
+     * @param premier Entier
+     * @param second Entier
+     * @return le quotient de la division de premier par second
+     * @throws ExecutionException lorsque le diviseur est nul
+     */
+    public static Entier quotient(Entier premier, Entier second) {
+        if (second.compareTo(new Entier (0)) == 0) {
+            throw new ExecutionException("Erreur. Division par 0. ");
+        }
+        return new Entier((int) premier.getValeur() / (int) second.getValeur());
+    }
+    
+    /** 
+     * Division de deux entiers
+     * @param premier Entier
+     * @param second Entier
+     * @return le reste de la division de premier par second
+     * @throws ExecutionException lorsque le diviseur est nul
+     */
+    public static Entier reste(Entier premier, Entier second) {
+        if (second.compareTo(new Entier (0)) == 0) {
+            throw new ExecutionException("Erreur. Division par 0. ");
+        }
+        return new Entier((int) premier.getValeur() % (int) second.getValeur());
+    }
 }
diff --git a/src/interpreteurlir/donnees/litteraux/tests/TestEntier.java b/src/interpreteurlir/donnees/litteraux/tests/TestEntier.java
new file mode 100644
index 0000000..bc1ca7f
--- /dev/null
+++ b/src/interpreteurlir/donnees/litteraux/tests/TestEntier.java
@@ -0,0 +1,301 @@
+/**
+ * TestEntier.java                                        13 mai 2021
+ * IUT-Rodez info1 2020-2021, pas de droits, pas de copyrights
+ */
+package interpreteurlir.donnees.litteraux.tests;
+
+import interpreteurlir.ExecutionException;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.donnees.litteraux.Entier;
+
+import static interpreteurlir.donnees.litteraux.Entier.*;
+import static info1.outils.glg.Assertions.*;
+
+import static java.lang.Integer.MIN_VALUE;
+import static java.lang.Integer.MAX_VALUE;
+
+/** 
+ * Tests des méthode de la classe Entier
+ * 
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class TestEntier {
+
+    /** Jeu d'entiers correctement instanciés à partir d'un entier */
+    private final Entier[] ENTIERS_INT = {
+        new Entier(MIN_VALUE),
+        new Entier(MAX_VALUE),
+        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),
+    };
+    
+    /** 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,
+        MAX_VALUE,
+        1,
+        -4587,
+        -569,
+        -3,
+        0,
+        2,
+        78,
+        781,
+        179892,
+    };
+
+    /**
+     * Test unitaire du constructeur Entier(String)
+     */
+    public static void testEntierString() {
+        final String[] INVALIDES = {
+                null,
+                "",
+                "          ",
+                "\t",
+                "\n",
+                "a",
+                "michel",
+                "Janis Joplin",
+                "(93)",
+                "      78.3",
+                "2147483648756",
+                "2147483648",
+                "+2147483648",
+                "-2147483649",
+                "-",
+                "+",
+        };
+        
+        for (int i = 0; i < INVALIDES.length; i++) {
+            try {
+                new Entier(INVALIDES[i]);
+                echec();
+            } catch (InterpreteurException lancee) {
+                // Test OK
+            }
+        }
+    }
+    
+    /** 
+     * Test unitaire de la méthode toString()
+     */
+    public void testToString() {
+        for (int i = 0; i < INT_VALIDES.length; i ++) {
+            assertTrue(ENTIERS_INT[i].toString()
+                       .compareTo(Integer.toString(INT_VALIDES[i])) == 0);
+        }
+    }
+    
+    /** 
+     * Test unitaire de la méthode toCompareTo()
+     */
+    public void testCompareTo() {
+        final Entier REF_MIN = new Entier(MIN_VALUE);
+        final Entier REF_MAX = new Entier(MAX_VALUE);
+        
+        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);
+        }
+        
+        for (int i = 0; i < ENTIERS_INT.length; i++) {
+            assertTrue(ENTIERS_INT[i].compareTo(new Entier(INT_VALIDES[i])) == 0);
+        }
+    }
+    
+    /** 
+     * Test unitaire de la méthode getValeur()
+     */
+    @SuppressWarnings("boxing")
+    public void testGetValeur() {
+        final Integer[] ATTENDUS = {
+                MIN_VALUE,
+                MAX_VALUE,
+                1,
+                -4587,
+                -569,
+                -3,
+                0,
+                2,
+                78,
+                781,
+                179892,
+        };
+        
+        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()
+     */
+    public void testSomme() {
+        final Entier[] ATTENDUS = {
+                new Entier(MIN_VALUE + MIN_VALUE),
+                new Entier(MAX_VALUE + MAX_VALUE),
+                new Entier(1 + 1),
+                new Entier(-9174),
+                new Entier(-1138),
+                new Entier(-6),
+                new Entier(0),
+                new Entier(4),
+                new Entier(156),
+                new Entier(1562),
+                new Entier(359784),
+        };
+        
+        for (int i = 0; i < ENTIERS_INT.length; i++) {
+            assertTrue(somme(ENTIERS_INT[i], ENTIERS_INT[i])
+                       .compareTo(ATTENDUS[i]) == 0);
+        }
+    }
+    
+    /** 
+     * Test unitaire de la méthode soustrait()
+     */
+    public void testSoustrait() {
+        Entier zero = new Entier(0); 
+        
+        for (int i = 0; i < ENTIERS_INT.length; i++) {
+            assertTrue(soustrait(ENTIERS_INT[i], ENTIERS_INT[i])
+                       .compareTo(zero) == 0);
+        }
+    }
+    
+    /** 
+     * Test unitaire de la méthode multiplie()
+     */
+    public void testMultiplie() {
+        final Entier[] ATTENDUS = {
+                new Entier(MIN_VALUE * MIN_VALUE),
+                new Entier(MAX_VALUE * MAX_VALUE),
+                new Entier(1 * 1),
+                new Entier(-4587 * (-4587)),
+                new Entier(-569 * (-569)),
+                new Entier(-3 * (-3)),
+                new Entier(0 * 0),
+                new Entier(2 * 2),
+                new Entier(78 * 78),
+                new Entier(781 * 781),
+                new Entier(179892 * 179892),
+        };
+        
+        for (int i = 0; i < ENTIERS_INT.length; i++) {
+            assertTrue(multiplie(ENTIERS_INT[i], ENTIERS_INT[i])
+                       .compareTo(ATTENDUS[i]) == 0);
+        }
+    }
+    
+    /** 
+     * Test unitaire de la méthode quotient()
+     */
+    public void testQuotient() {
+        final Entier DIVISEUR = new Entier(2);
+        
+        final Entier[] ATTENDUS = {
+                new Entier(-1073741824),
+                new Entier(1073741823),
+                new Entier(0),
+                new Entier(-2293),
+                new Entier(-284),
+                new Entier(-1),
+                new Entier(0),
+                new Entier(1),
+                new Entier(39),
+                new Entier(390),
+                new Entier(89946)
+        };
+        
+        for (int i = 0; i < ENTIERS_INT.length; i++) {
+            assertTrue(quotient(ENTIERS_INT[i], DIVISEUR)
+                       .compareTo(ATTENDUS[i]) == 0);
+        }
+    }
+    
+    /** 
+     * Test unitaire de la méthode quotient()
+     */
+    public void testQuotientParZero() {
+        final Entier DIVISEUR = new Entier(0);
+        
+        for (int i = 0; i < ENTIERS_INT.length; i++) {
+            try {
+                quotient(ENTIERS_INT[i], DIVISEUR);
+                echec();
+            } catch (ExecutionException lancee) {
+                // Test OK
+            }
+        }
+    }
+    
+    /** 
+     * Test unitaire de la méthode quotient()
+     */
+    public void testReste() {
+        final Entier DIVISEUR = new Entier(2);
+        
+        final Entier[] ATTENDUS = {
+                new Entier(0),
+                new Entier(1),
+                new Entier(1),
+                new Entier(-1),
+                new Entier(-1),
+                new Entier(-1),
+                new Entier(0),
+                new Entier(0),
+                new Entier(0),
+                new Entier(1),
+                new Entier(0)
+        };
+        
+        for (int i = 0; i < ENTIERS_INT.length; i++) {
+            assertTrue(reste(ENTIERS_INT[i], DIVISEUR)
+                       .compareTo(ATTENDUS[i]) == 0);
+        }
+    }
+    
+    /** 
+     * Test unitaire de la méthode quotient()
+     */
+    public void testResteParZero() {
+        final Entier DIVISEUR = new Entier(0);
+        
+        for (int i = 0; i < ENTIERS_INT.length; i++) {
+            try {
+                reste(ENTIERS_INT[i], DIVISEUR);
+                echec();
+            } catch (ExecutionException lancee) {
+                // Test OK
+            }
+        }
+    }
+}
diff --git a/src/interpreteurlir/donnees/tests/TestIdentificateur.java b/src/interpreteurlir/donnees/tests/TestIdentificateur.java
index dfea654..0d42314 100644
--- a/src/interpreteurlir/donnees/tests/TestIdentificateur.java
+++ b/src/interpreteurlir/donnees/tests/TestIdentificateur.java
@@ -6,6 +6,7 @@ package interpreteurlir.donnees.tests;
 
 import static info1.outils.glg.Assertions.*;
 
+import interpreteurlir.InterpreteurException;
 import interpreteurlir.donnees.Identificateur;
 
 /**
@@ -43,9 +44,9 @@ public class TestIdentificateur {
             null,
             "",
 
-            // Fait au maximum 24 caractères
+            // Fait au maximum 25 caractères
             "$jeSuisUnTresLongIdentificateur", // 30 char
-            "$jeSuisUnTresLongIdentific",
+            "$jeSuisUnTresLongIdentifica",
 
             // Espaces
             "id 3a",
@@ -67,7 +68,7 @@ public class TestIdentificateur {
             try {
                 new Identificateur(INVALIDE[noJeu]);
                 echec();
-            } catch (IllegalArgumentException lancee) {
+            } catch (InterpreteurException lancee) {
                 // Test OK
             }
         }
diff --git a/src/interpreteurlir/donnees/tests/TestIdentificateurChaine.java b/src/interpreteurlir/donnees/tests/TestIdentificateurChaine.java
index 29d04ef..f507c16 100644
--- a/src/interpreteurlir/donnees/tests/TestIdentificateurChaine.java
+++ b/src/interpreteurlir/donnees/tests/TestIdentificateurChaine.java
@@ -8,6 +8,7 @@ package interpreteurlir.donnees.tests;
 
 import static info1.outils.glg.Assertions.*;
 
+import interpreteurlir.InterpreteurException;
 import interpreteurlir.donnees.IdentificateurChaine;
 
 /**
@@ -19,7 +20,7 @@ import interpreteurlir.donnees.IdentificateurChaine;
  * @author Lucas Vabre
  */
 public class TestIdentificateurChaine {
-	/** Jeu d'identificateurs de chaîne correctement instanciés */
+    /** Jeu d'identificateurs de chaîne correctement instanciés */
     private static IdentificateurChaine[] FIXTURE = {
             new IdentificateurChaine("$a"),
             new IdentificateurChaine("$A"),
@@ -27,66 +28,67 @@ public class TestIdentificateurChaine {
             new IdentificateurChaine("$Alpha"),
             new IdentificateurChaine("$Alpha5"),
             new IdentificateurChaine("$jeSuisUnTresLongIdentifi")
-	};
-    
+    };
+
     /**
      * Tests unitaires du constructeur IdentificateurEntier(String identificateur)
      */
     public static void testIdentificateurChaineString() {
-    	final String[] INVALIDE = {
-    	    null,
-    	    "",
-    	    
-    	    // Commence par une lettre
-            "9alpha",
-            "  5alpha",
-                
-            // Fait au maximum 24 caractères
-            "$jeSuisUnTresLongIdentificateur", // 30 char
-            "$jeSuisUnTresLongIdentific",
-                
-            // Espaces
-            "id 3a",
-            "$id 3a",
-            " ",
-            "$ ",
-            
-            // caractères d'échapements
-            "\t",
-            "\n",
-            "$\t",
-            "$\n",
-            
-            // , cas particulier
-            "$",
-            "$1"
-    	};
-    	
-    	for(int noJeu = 0; noJeu < INVALIDE.length ; noJeu++) {
-    		try {
-    			new IdentificateurChaine(INVALIDE[noJeu]);
-    			echec();
-    		} catch (IllegalArgumentException lancee) {
-    			// test OK
-    		}
-    	}
+        final String[] INVALIDE = {
+                null,
+                "",
+
+                // Commence par une lettre
+                "9alpha",
+                "  5alpha",
+
+                // 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
+                "$",
+                "$1"
+        };
+
+        for(int noJeu = 0; noJeu < INVALIDE.length ; noJeu++) {
+            try {
+                new IdentificateurChaine(INVALIDE[noJeu]);
+                echec();
+            } catch (InterpreteurException lancee) {
+                // test OK
+            }
+        }
+        
     }
-    
+
     /**
      * Tests unitaires de getNom()
      */
     public static void testGetNom() {
         final String[] NOM_VALIDES = {
-            "$a",
-            "$A",
-            "$alpha",
-            "$Alpha",
-            "$Alpha5",
-            "$jeSuisUnTresLongIdentifi"
+                "$a",
+                "$A",
+                "$alpha",
+                "$Alpha",
+                "$Alpha5",
+                "$jeSuisUnTresLongIdentifi"
         };
-    	
-    	for (int noJeu = 0 ; noJeu < NOM_VALIDES.length ; noJeu++) {
-    		assertEquivalence(NOM_VALIDES[noJeu], FIXTURE[noJeu].getNom());
-    	}
+
+        for (int noJeu = 0 ; noJeu < NOM_VALIDES.length ; noJeu++) {
+            assertEquivalence(NOM_VALIDES[noJeu], FIXTURE[noJeu].getNom());
+        }
     }
 }
diff --git a/src/interpreteurlir/donnees/tests/TestIdentificateurEntier.java b/src/interpreteurlir/donnees/tests/TestIdentificateurEntier.java
index 0d5c604..5ab121d 100644
--- a/src/interpreteurlir/donnees/tests/TestIdentificateurEntier.java
+++ b/src/interpreteurlir/donnees/tests/TestIdentificateurEntier.java
@@ -8,6 +8,7 @@ package interpreteurlir.donnees.tests;
 
 import static info1.outils.glg.Assertions.*;
 
+import interpreteurlir.InterpreteurException;
 import interpreteurlir.donnees.IdentificateurEntier;
 
 /**
@@ -19,65 +20,65 @@ import interpreteurlir.donnees.IdentificateurEntier;
  * @author Lucas Vabre
  */
 public class TestIdentificateurEntier {
-	
-	/** Jeu d'identificateurs d'entier correctement instanciés */
+
+    /** Jeu d'identificateurs d'entier correctement instanciés */
     private static IdentificateurEntier[] FIXTURE = {
             new IdentificateurEntier("a"),
             new IdentificateurEntier("A"),
             new IdentificateurEntier("alpha"),
             new IdentificateurEntier("Alpha"),
             new IdentificateurEntier("Alpha5"),
-            new IdentificateurEntier("jeSuisUnTresLongIdentifi")
-	};
-    
+            new IdentificateurEntier("jeSuisUnTresLongIdentific")
+    };
+
     /**
      * Tests unitaires du constructeur IdentificateurEntier(String identificateur)
      */
     public static void testIdentificateurEntierString() {
-    	final String[] INVALIDE = {
-    		// Commence par une lettre
-    		"9alpha",
-    		"  5alpha",
-    		"$beta",
-    		
-    		// Fait au maximum 24 caractères
-    		"jeSuisUnTresLongIdentificateur", // 30 char
-    		"jeSuisUnTresLongIdentific",
-    		
-    		// Espaces, caractères d'échapements, cas particulier
-    		"id 3a",
-    		"",
-    		" ",
-    		"\t",
-    		"\n",
-    		null
-    	};
-    	
-    	for(int noJeu = 0; noJeu < INVALIDE.length ; noJeu++) {
-    		try {
-    			new IdentificateurEntier(INVALIDE[noJeu]);
-    			echec();
-    		} catch (IllegalArgumentException lancee) {
-    			// test OK
-    		}
-    	}
+        final String[] INVALIDE = {
+                // Ne commence pas  par une lettre
+                "9alpha",
+                "  5alpha",
+                "$beta",
+
+                // Fait plus de 25 caractères
+                "jeSuisUnTresLongIdentificateur", // 30 char
+                "jeSuisUnTresLongIdentifica",
+
+                // Espaces, caractères d'échapements, cas particulier
+                "id 3a",
+                "",
+                " ",
+                "\t",
+                "\n",
+                null
+        };
+
+        for(int noJeu = 0; noJeu < INVALIDE.length ; noJeu++) {
+            try {
+                new IdentificateurEntier(INVALIDE[noJeu]);
+                echec();
+            } catch (InterpreteurException lancee) {
+                // test OK
+            }
+        }
     }
-    
+
     /**
      * Tests unitaires de getNom()
      */
     public static void testGetNom() {
-    	final String[] NOM_VALIDES = {
-    			"a",
-    		    "A",
-    		    "alpha",
-    		    "Alpha",
-    		    "Alpha5",
-    		    "jeSuisUnTresLongIdentifi"
-    	};
-    	
-    	for (int noJeu = 0 ; noJeu < NOM_VALIDES.length ; noJeu++) {
-    		assertEquivalence(NOM_VALIDES[noJeu], FIXTURE[noJeu].getNom());
-    	}
+        final String[] NOM_VALIDES = {
+                "a",
+                "A",
+                "alpha",
+                "Alpha",
+                "Alpha5",
+                "jeSuisUnTresLongIdentific"
+        };
+
+        for (int noJeu = 0 ; noJeu < NOM_VALIDES.length ; noJeu++) {
+            assertEquivalence(NOM_VALIDES[noJeu], FIXTURE[noJeu].getNom());
+        }
     }
 }
diff --git a/src/interpreteurlir/expressions/ExpressionEntier.java b/src/interpreteurlir/expressions/ExpressionEntier.java
index 99b3610..98ca19b 100644
--- a/src/interpreteurlir/expressions/ExpressionEntier.java
+++ b/src/interpreteurlir/expressions/ExpressionEntier.java
@@ -4,8 +4,14 @@
  */
 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.
@@ -16,6 +22,19 @@ import interpreteurlir.donnees.litteraux.Entier;
  * @author Lucas Vabre
  */
 public class ExpressionEntier extends Expression {
+    
+    /** Liste des opérateurs possibles sur les entiers */
+    private static final char[] OPERATEURS = {'+', '-', '*', '/', '%'};
+    
+    /** message d'erreur de chaîne null ou vide */
+    private static final String ERREUR_VIDE = 
+            "une expression ne peut être vide";
+    
+    /** Erreur opérande attendue */
+    private static final String OPERANDE_D_MANQUANT = 
+            " : opérande droit attendu";
+    
+    private char operateur;
 
     /**
      * Initalise une expression de type Entier avec les liens nécessaires à son
@@ -26,7 +45,85 @@ public class ExpressionEntier extends Expression {
      */
     public ExpressionEntier(String texteExpression) {
         super();
-        // TODO
+        String gauche;
+        String droite;
+        String aTraiter;
+        
+        if (texteExpression == null || texteExpression.isBlank())
+            throw new InterpreteurException(ERREUR_VIDE);
+        
+        aTraiter = texteExpression.trim();
+        
+        /* Traitement d'une éventuelle affectation */
+        int indexEgal = aTraiter.indexOf('=');
+        if (indexEgal > 0) {
+            identificateursOperandes[INDEX_AFFECTATION] = 
+                new IdentificateurEntier(aTraiter.substring(0, indexEgal).trim());
+        
+            aTraiter = aTraiter.substring(indexEgal + 1).trim();
+        }
+        
+        /* Repérage de l'opérateur et de l'opérande droite s'ils existent */
+        int indexOperateur = detecterOperateur(aTraiter);
+        gauche = aTraiter.trim();
+        if (indexOperateur > 0) {
+            operateur = aTraiter.charAt(indexOperateur);
+            gauche = aTraiter.substring(0, indexOperateur).trim();
+            
+            if (aTraiter.length() - 1 <= indexOperateur)
+                throw new ExecutionException(aTraiter + OPERANDE_D_MANQUANT);
+            
+            droite = aTraiter.substring(indexOperateur + 1).trim();
+            initialiserOperande(droite, INDEX_OPERANDE_D);
+        }
+        
+        initialiserOperande(gauche, INDEX_OPERANDE_G);
+    }
+
+    /**
+     * Détecte la présence d'un opérateur dans cette expression et renvoie
+     * sa position
+     * @param expression dont on cherche à connaître la position de l'opérande
+     * @return position sous forme d'entier, -1 si pas d'opérateur
+     */
+    private static int detecterOperateur(String expression) {
+        for (int i = 1 ; i < expression.length() ; 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
+     */
+    private void initialiserOperande(String operande, int index) {
+        if (INDEX_OPERANDE_G != index && INDEX_OPERANDE_D != index) {
+            throw new IllegalArgumentException("index invalide");
+        }
+        
+        if (operandeEstLitteral(operande)) {
+            litterauxOperandes[index] = new Entier(operande);
+        } else {
+            identificateursOperandes[index] = 
+                    new IdentificateurEntier(operande);
+        }
+        
+    }
+
+    /**
+     * 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
@@ -34,17 +131,71 @@ public class ExpressionEntier extends Expression {
      */
     @Override
     public Entier calculer() {
-        // TODO Auto-generated method stub
-        return null;
+        Entier valeur;
+        super.calculer();
+        
+        /* Détermine opérandeGauche */
+        Identificateur idGauche = 
+                identificateursOperandes[INDEX_OPERANDE_G];
+        Entier operandeG = (Entier)(idGauche == null 
+                           ? litterauxOperandes[INDEX_OPERANDE_G] 
+                           : contexteGlobal.lireValeurVariable(idGauche));
+        
+        /* Détermine possible operandeDroite */
+        Identificateur idDroite = 
+                identificateursOperandes[INDEX_OPERANDE_D];
+        Entier operandeD = null;
+        if (idDroite != null || litterauxOperandes[INDEX_OPERANDE_D] != null) {
+            operandeD = (Entier)(idDroite == null 
+                                 ? litterauxOperandes[INDEX_OPERANDE_D] 
+                                 : contexteGlobal.lireValeurVariable(idDroite));
+        }
+        
+        /* Calcul de la valeur */
+        valeur = operandeD == null 
+                 ? operandeG 
+                 : switch (operateur) {
+                   case '+' -> Entier.somme(operandeG, operandeD);
+                   case '-' -> Entier.soustrait(operandeG, operandeD);
+                   case '*' -> Entier.multiplie(operandeG, operandeD);
+                   case '/' -> Entier.quotient(operandeG, operandeD);
+                   case '%' -> Entier.reste(operandeG, operandeD);
+                   default -> operandeG;
+                   };
+        
+        /* Affectation si nécessaire */
+        if (identificateursOperandes[INDEX_AFFECTATION] != null) {
+            contexteGlobal.ajouterVariable(
+                    identificateursOperandes[INDEX_AFFECTATION], valeur);
+        }
+        
+        return valeur;
     }
 
-    /* non javadoc
-     * @see interpreteurlir.expressions.Expression#toString()
+    /*
+     * Non - javadoc
+     * @see java.lang.Object#toString()
      */
     @Override
     public String toString() {
-        // TODO Auto-generated method stub
-        return "ExpressionEntier#toString() BOUCHON";
+        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();
     }
-
 }
\ No newline at end of file
diff --git a/src/interpreteurlir/expressions/tests/TestExpression.java b/src/interpreteurlir/expressions/tests/TestExpression.java
index e55c4c9..81027c0 100644
--- a/src/interpreteurlir/expressions/tests/TestExpression.java
+++ b/src/interpreteurlir/expressions/tests/TestExpression.java
@@ -112,7 +112,6 @@ public class TestExpression {
             "entier = 78  ",
             " nombre= nombre + 78",
             " entier =78 *2"
-            // TODO expressionEntier
         };
         
         final int INDEX_DEBUT_ENTIER = 12;
diff --git a/src/interpreteurlir/expressions/tests/TestExpressionEntier.java b/src/interpreteurlir/expressions/tests/TestExpressionEntier.java
index 5b8f5d1..dbf5937 100644
--- a/src/interpreteurlir/expressions/tests/TestExpressionEntier.java
+++ b/src/interpreteurlir/expressions/tests/TestExpressionEntier.java
@@ -4,10 +4,21 @@
  */
 package interpreteurlir.expressions.tests;
 
+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;
 
 /**
- * Tests unitaires de {@link Expression}
+ * Tests unitaires de {@link ExpressionEntier}
  * @author Nicolas Caminade
  * @author Sylvan Courtiol
  * @author Pierre Debas
@@ -15,5 +26,135 @@ import interpreteurlir.expressions.Expression;
  * @author Lucas Vabre
  */
 public class TestExpressionEntier {
-
+    
+    /* jeu de test d'expressions entières valides */
+    private static final ExpressionEntier[] FIXTURE = {
+        new ExpressionEntier("entier = 2 + 3"),
+        new ExpressionEntier("entier=2*3"),
+        new ExpressionEntier("bob= marcel-2"),
+        new ExpressionEntier("45 +14"),
+        new ExpressionEntier("45 * -2"),
+        new ExpressionEntier("affectation = 64"),
+        new ExpressionEntier("affectation= marcel"),
+        new ExpressionEntier("entier = j34n + pi3rr3"),
+        new ExpressionEntier("       entier   = j34n"),
+        new ExpressionEntier("    42"),
+        new ExpressionEntier("rep0ns3=  42"),
+        new ExpressionEntier("division = 12/0"),
+        new ExpressionEntier("modulo = 12%0")
+    };
+    
+    /**
+     * Tests unitaires de {@link ExpressionEntier#ExpressionEntier(String)}
+     */
+    public static void testExpressionEntierString() {
+        final String[] INVALIDES = {
+            /* identificateurs non valides */
+            "$bob =2",
+            "j@ck= 2+3",
+            "@75S= #michel",
+            "unidentificateurbeaucouptroplong = 0",
+            "truc.length = 9000",
+            
+            /* types non compatibles */
+            "resultat = \"50\"",
+            "resultat = 30.2",
+            "resultat = 10 / 2.0",
+            
+            /* Nombre incorrect d'opérandes */
+            "resultat = 10 * 5 + 3",
+            "famille = marcel + jean + albert",
+            "divisionRatee = 5 /",
+            "ratee=*7",
+        };
+        
+        for (String invalide : INVALIDES) {
+            try {
+                new ExpressionEntier(invalide);
+                echec();
+                
+            } catch(InterpreteurException | ExecutionException lancee) {
+                // Empty body
+            }
+        }
+    }
+    
+    /**
+     * Tests unitaires de {@link ExpressionEntier#calculer()}
+     */
+    public static void testCalculer() {
+        final Entier[] RESULTATS_ATTENDUS = {
+            new Entier(5),
+            new Entier(6),
+            new Entier(-2),
+            new Entier(59),
+            new Entier(-90),
+            new Entier(64),
+            new Entier(0),
+            new Entier(3),
+            new Entier(1),
+            new Entier(42),
+            new Entier(42),
+            new Entier(0),  // Bouchon
+            new Entier(0)   // Bouchon
+        };
+        
+        /* Exception levée si contexte non référencé */
+        try {
+            FIXTURE[0].calculer();
+            echec();
+        } catch (RuntimeException e) {
+            // vide
+        }
+        
+        /* 
+         * Création contexte (avec marcel = 0 j34n = 1 et pi3rr3 = 2) et 
+         * référencement 
+         */
+        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));
+        Expression.referencerContexte(contexteGlobal);
+        System.out.print("\tContexte initial : \n" + contexteGlobal);
+        
+        for (int i = 0 ; i < FIXTURE.length ; i++) {
+            try {
+                System.out.println("\nCalcul de : " + FIXTURE[i]);
+                assertTrue(FIXTURE[i].calculer()
+                                     .compareTo(RESULTATS_ATTENDUS[i]) == 0);
+                System.out.println("\tContexte : \n" + contexteGlobal);
+            } catch (ExecutionException divzero) {
+                System.out.println("Attention Division par 0");
+            }
+        }
+    }
+    
+    /**
+     * test de toString()
+     */
+    public static void testToString() {
+        final String[] ATTENDUES = {
+                "entier = 2 + 3",
+                "entier = 2 * 3",
+                "bob = marcel - 2",
+                "45 + 14",
+                "45 * -2",
+                "affectation = 64",
+                "affectation = marcel",
+                "entier = j34n + pi3rr3",
+                "entier = j34n",
+                "42",
+                "rep0ns3 = 42",
+                "division = 12 / 0",
+                "modulo = 12 % 0"
+        };
+        
+        for (int i = 0 ; i < FIXTURE.length ; i++) {
+            assertTrue(FIXTURE[i].toString().equals(ATTENDUES[i]));
+        }
+    }
 }
diff --git a/src/interpreteurlir/motscles/Commande.java b/src/interpreteurlir/motscles/Commande.java
index 36e102b..4cfa3a1 100644
--- a/src/interpreteurlir/motscles/Commande.java
+++ b/src/interpreteurlir/motscles/Commande.java
@@ -6,6 +6,7 @@ package interpreteurlir.motscles;
 
 import interpreteurlir.Contexte;
 import interpreteurlir.InterpreteurException;
+import interpreteurlir.programmes.Programme;
 
 /**
  * Une commande (générale) n'a aucun comportement. 
@@ -20,6 +21,9 @@ import interpreteurlir.InterpreteurException;
  */
 public class Commande {
     
+    /** référence du programme global */
+    protected static Programme programmeGlobal;
+    
     /** référence du contexte possiblement manié directement par la commande */
     protected Contexte contexte;
 
@@ -52,6 +56,27 @@ public class Commande {
         // pas de comportement pour une Commande générale
         return false; // pas de feedback
     }
+    
+    /**
+     * Référence le programme pour accéder et modifier le programme chargé.
+     * Le référencement vaut pour toutes les commandes/instructions
+     * et est possible une unique fois.
+     * @param aReferencer référence du programme global
+     * @return <ul><li>true si le programme a pu être référencé</li>
+     *             <li>true si aReferencer == programme déjà référencer</li>
+     *             <li>false si aReferencer est null</li>
+     *             <li>false si un programme est déjà référencer</li>
+     *         </ul>
+     */
+    public static boolean referencerProgramme(Programme aReferencer) {
+        if (aReferencer != null 
+                && (   programmeGlobal == null 
+                    || aReferencer == programmeGlobal)) {
+            programmeGlobal = aReferencer;
+            return true;
+        }
+        return false;
+    }
         
     
 
diff --git a/src/interpreteurlir/motscles/CommandeDebut.java b/src/interpreteurlir/motscles/CommandeDebut.java
index 8019eda..90fa70c 100644
--- a/src/interpreteurlir/motscles/CommandeDebut.java
+++ b/src/interpreteurlir/motscles/CommandeDebut.java
@@ -20,8 +20,6 @@ import interpreteurlir.InterpreteurException;
  * @author Lucas Vabre
  */
 public class CommandeDebut extends Commande {
-
-    // TODO adapter la classe aux programmes
     
     /**
      * Initialise une commande debut qui est sans arguments 
@@ -50,6 +48,7 @@ public class CommandeDebut extends Commande {
     @Override
     public boolean executer() {
         contexte.raz();
+        programmeGlobal.raz();
         return false;
     }
 
diff --git a/src/interpreteurlir/motscles/CommandeEfface.java b/src/interpreteurlir/motscles/CommandeEfface.java
new file mode 100644
index 0000000..4c8274e
--- /dev/null
+++ b/src/interpreteurlir/motscles/CommandeEfface.java
@@ -0,0 +1,69 @@
+/**
+ * CommandeEfface.java                                             16 mai 2021
+ * IUT info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.motscles;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.programmes.Etiquette;
+
+/**
+ * Instruction permettant d'effacer une, plusieurs, ou l'intégralité des lignes
+ * de code d'un programme écrit dans l'interpréteur LIR.
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+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>";
+    
+    /** Plage de suppression des lignes de code */
+    private Etiquette[] plageSuppression;
+
+    /**
+     * Initialise cette InstructionEfface à partir des arguments et du
+     * 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
+     */
+    public CommandeEfface(String arguments, Contexte contexte) {
+        super(arguments, contexte);
+        plageSuppression = analyserArguments(arguments);
+    }
+
+    /*
+     * Non - javadoc
+     * @see interpreteurlir.motscles.instructions.Instruction#executer()
+     */
+    @Override
+    public boolean executer() {
+        programmeGlobal.effacer(plageSuppression[0], plageSuppression[1]);
+        return false;
+    }
+
+    /**
+     * Découpe la chaîne argument en une plage de deux étiquettes
+     * @param aDecouper chaîne à analyser
+     * @return la plage de lignes de code à supprimer sous forme de tableau
+     *         d'étiquettes.
+     */
+    private static Etiquette[] analyserArguments(String aDecouper) {
+        String[] valeurs = aDecouper.split(":");
+        if (valeurs.length != 2)
+            throw new InterpreteurException(ERREUR_NB_ARGS);
+        
+        Etiquette[] aRenvoyer = {
+            new Etiquette(valeurs[0]), 
+            new Etiquette(valeurs[1])
+        };
+       
+        return aRenvoyer;
+    }
+}
diff --git a/src/interpreteurlir/motscles/CommandeLance.java b/src/interpreteurlir/motscles/CommandeLance.java
new file mode 100644
index 0000000..5531e8d
--- /dev/null
+++ b/src/interpreteurlir/motscles/CommandeLance.java
@@ -0,0 +1,70 @@
+/**
+ * CommandeLance.java                                        15 mai 2021
+ * IUT-Rodez info1 2020-2021, pas de droits, pas de copyrights
+ */
+package interpreteurlir.motscles;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.programmes.Programme;
+import interpreteurlir.programmes.Etiquette;
+
+/** 
+ * Démarre l'exécution d'un programme à partir de son plus petit numéro
+ * d'étiquette.
+ * 
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class CommandeLance extends Commande {
+    
+    private Etiquette debutLancer;
+
+    /** 
+     * Initialise la commande lance avec ses arguments et le contexte
+     * @param arguments
+     * @param contexte
+     * @throws InterpreteurException en cas d'erreur de syntaxe à
+     *                               la création d'une étiquette
+     */
+    public CommandeLance(String arguments, Contexte contexte) {
+        super(arguments, contexte);
+        
+        if (arguments.isBlank()) {
+            debutLancer = null;
+        } else {
+            debutLancer = new Etiquette(arguments);
+        }
+    }
+    
+    /**
+     * Exécution de la commande :
+     * <ul><li>Lance le programme à partir de l'étiquette la plus 
+     *         petite s'il n'y a pas d'argument</li>
+     *      <li>Lance le programme à partir de l'étiquette passée
+     *          en paramètre</li>
+     * </ul>
+     * @return true car un feedback est affiché
+     * @throws RuntimeException si un programme n'est pas référencé
+     *                          dans la classe {@link Commande}
+     */
+    public boolean executer() {
+        
+        final String ERREUR = "erreur exécution";
+        
+        if (programmeGlobal == null) {
+            throw new RuntimeException(ERREUR);
+        }
+        
+        if (debutLancer == null) {
+            programmeGlobal.lancer();
+        } else {
+            programmeGlobal.lancer(debutLancer);
+        }
+        
+        return true;
+    }
+}
diff --git a/src/interpreteurlir/motscles/CommandeListe.java b/src/interpreteurlir/motscles/CommandeListe.java
new file mode 100644
index 0000000..6747953
--- /dev/null
+++ b/src/interpreteurlir/motscles/CommandeListe.java
@@ -0,0 +1,90 @@
+/**
+ * CommandeListe.java                                        15 mai 2021
+ * IUT-Rodez info1 2020-2021, pas de droits, pas de copyrights
+ */
+package interpreteurlir.motscles;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.programmes.Etiquette;
+import static interpreteurlir.programmes.Etiquette.*;
+
+/** 
+ * Commande liste affiche les lignes de codes du programme,
+ * soit dans leur intégralité, soit dans un intervalle donné
+ * 
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class CommandeListe extends Commande {
+    
+    private Etiquette debut;
+    
+    private Etiquette fin;
+
+    /** 
+     * Initialise la commande liste avec ses arguments et le contexte
+     * 
+     * @param arguments
+     * @param contexte
+     * @throws InterpreteurException en cas d'erreur de syntaxe lors
+     *                               de l'instanciation des étiquettes
+     */
+    public CommandeListe(String arguments, Contexte contexte) {
+        super(arguments, contexte);
+        
+        final int ARGS_DEBUT = 0;
+        final int   ARGS_FIN = 1;
+        
+        final String ERREUR_INTERVALLE = "usage <etiquette debut>:"
+                                         + "<etiquette fin> avec "
+                                         + "<etiquette debut> < "
+                                         + "<etiquette fin> ";
+        
+        if (arguments.isBlank()) {
+            debut = new Etiquette(VALEUR_ETIQUETTE_MIN);
+            fin   = new Etiquette(VALEUR_ETIQUETTE_MAX);
+        } else {
+            String[] decoupage = arguments.split(":");
+            
+            if (decoupage.length < 2) {
+                throw new InterpreteurException(ERREUR_INTERVALLE);
+            }
+            
+            debut = new Etiquette(decoupage[ARGS_DEBUT]);
+            fin   = new Etiquette(decoupage[ARGS_FIN]);
+            
+            if (debut.compareTo(fin) > 0) {
+                throw new InterpreteurException(ERREUR_INTERVALLE);
+            }
+        }
+        
+    }
+
+    /**
+     * Exécution de la commande :
+     * <ul><li>Affiche les lignes de code du programme entre l'étiquette
+     *         de début et celle de fin passées en argument</li>
+     *      <li>Affiche l'intégralité des lignes de code du programme</li>
+     * </ul>
+     * @return true car un feedback est affiché
+     * @throws RuntimeException si un programme n'est pas référencé
+     *                          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));
+        }
+        return true;
+    }
+
+}
diff --git a/src/interpreteurlir/motscles/instructions/InstructionAffiche.java b/src/interpreteurlir/motscles/instructions/InstructionAffiche.java
new file mode 100644
index 0000000..56aa71e
--- /dev/null
+++ b/src/interpreteurlir/motscles/instructions/InstructionAffiche.java
@@ -0,0 +1,74 @@
+/**
+ * InstructionAffiche.java                                             13 mai 2021
+ * IUT info1 2020-2021, pas de copyright, aucun droit
+ */
+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
+ * expression ne doit pas contenir d'affectation. Si aucune expression n'est
+ * passée en argument, effectue un retour à la ligne.
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class InstructionAffiche extends Instruction {
+    
+    /** Erreur d'affectation illegale */
+    private static final String AFFECTATION_ILLEGALE = "affectation illegale";
+
+    /**
+     * Initialise cette InstructionAffiche à partir de son contexte global
+     * d'exécution et de l'expression passée en argument. Lève une exception
+     * si cette expression contient une affectation.
+     * @param arguments contenant l'expression dont le résultat doit être
+     *        affiché.
+     * @param contexte global de la session d'interpreteurlir
+     * @throws InterpreteurException si la chaîne arguments contient un signe
+     *         égal en dehors d'un littéral de chaîne de caractères.
+     */
+    public InstructionAffiche(String arguments, Contexte contexte) {
+        super(arguments, contexte);
+
+        if (ExpressionChaine.indexOperateur(arguments, '=') >= 0)
+            throw new InterpreteurException(AFFECTATION_ILLEGALE);
+        
+        aExecuter = arguments.isBlank() 
+                    ? null
+                    : Expression.determinerTypeExpression(arguments.trim());
+    }
+
+    /*
+     * Non - javadoc
+     * @see interpreteurlir.motscles.instructions.Instruction#executer()
+     */
+    @Override
+    public boolean executer() {
+        if (aExecuter == null) {
+            System.out.println();
+        } else {
+            System.out.print(aExecuter.calculer().getValeur());
+        }
+        
+        return true;
+    }
+
+    /*
+     * Non - javadoc
+     * @see interpreteurlir.motscles.instructions.Instruction#toString()
+     */
+    @Override
+    public String toString() {
+        return "affiche" + (aExecuter == null ? "" 
+                                              : " " + aExecuter.toString());
+    }
+    
+    
+}
diff --git a/src/interpreteurlir/motscles/instructions/InstructionEntre.java b/src/interpreteurlir/motscles/instructions/InstructionEntre.java
new file mode 100644
index 0000000..50f0c8e
--- /dev/null
+++ b/src/interpreteurlir/motscles/instructions/InstructionEntre.java
@@ -0,0 +1,97 @@
+/**
+ * InstructionEntre.java                              13 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.donnees.*;
+import interpreteurlir.donnees.litteraux.Chaine;
+import interpreteurlir.donnees.litteraux.Entier;
+
+import java.util.Scanner;
+
+/** 
+ * Instruction qui attend que l'utilisateur
+ * entre une valeur sur l'entrée standard du type de l'identificateur argument
+ * cette valeur sera affectée dans une variable ayant cet
+ * identificateur dans le contexte.
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class InstructionEntre extends Instruction {
+    
+    /** 
+     * Identificateur à affecter à partir de la valeur
+     * saisie à l'execution de cette instruction 
+     */
+    private Identificateur id; 
+
+    /** 
+     * Initialise une instruction entre avec un
+     * identificateur chaine ou entier en argument
+     * @param arguments représentation texte de l'indentificateur
+     * @param contexte contexte pour l'enregistrement de la valeur
+     *                 saisie à l'execution
+     * @throws InterpreteurException si argument n'est pas
+     *         un identificateur valide
+     * @throws NullPointerException si contexte ou argument est null
+     */
+    public InstructionEntre(String arguments, Contexte contexte) {
+        super(arguments, contexte);
+        final String ERREUR_ARG = "Entre attend un identificateur en argument";
+        
+        if (arguments.isBlank()) {
+            throw new InterpreteurException(ERREUR_ARG);
+        }
+        
+        if (arguments.indexOf("$") >= 0) {
+            id = new IdentificateurChaine(arguments.trim());
+        } else {
+            id = new IdentificateurEntier(arguments.trim());
+        }
+    }
+    
+    /**
+     * Execution de l'instruction :
+     * L'utilisateur saisi une valeur sur l'entrée standard qui sera affectée
+     * à une variable dans le contexte ayant comme identificateur celui
+     * de l'instruction si le type est compatible
+     * @return false car aucun feedback affiché directement
+     * @throws ExecutionException si la valeur saisie n'est pas compatible
+     *         avec le type de l'identificateur de l'instruction  
+     */
+    public boolean executer() {
+        
+        final String MESSAGE_ERREUR_TYPE = "Le type saisi ne correspond"
+                                           + " pas au type demandé";
+        Scanner entree = new Scanner(System.in);
+        
+        String valeurSaisie = entree.nextLine();
+        
+        try {
+            if (id instanceof IdentificateurEntier) {
+                contexte.ajouterVariable(id, new Entier(valeurSaisie.trim()));
+            } else {
+                contexte.ajouterVariable(id, new Chaine("\"" 
+                                                        + valeurSaisie + "\""));
+            }
+        } catch (InterpreteurException lancee) {
+            throw new ExecutionException(MESSAGE_ERREUR_TYPE);
+        }
+        return false;
+    }
+
+    /* non javadoc
+     * @see java.lang.Object#toString()
+     */
+    @Override
+    public String toString() {
+        return "entre " + id;
+    }
+}
diff --git a/src/interpreteurlir/motscles/instructions/InstructionProcedure.java b/src/interpreteurlir/motscles/instructions/InstructionProcedure.java
new file mode 100644
index 0000000..44a9170
--- /dev/null
+++ b/src/interpreteurlir/motscles/instructions/InstructionProcedure.java
@@ -0,0 +1,77 @@
+/**
+ * InstructionProcedure.java                                        15 mai 2021
+ * IUT-Rodez info1 2020-2021, pas de droits, pas de copyrights
+ */
+package interpreteurlir.motscles.instructions;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.ExecutionException;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.programmes.Etiquette;
+
+/**
+ * Instruction qui transfère l'exécution au numéro d'étiquette spécifié
+ * et reprendra en séquence lorsque la procédure sera terminée
+ * (instruction retour)
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ *
+ */
+public class InstructionProcedure extends Instruction {
+    
+    /** Etiquette désignant le début de la procedure à exécuter */
+    private Etiquette debutProcedure;
+    
+    /**
+     * Initialise une procédure avec une étiquette en argument.
+     * @param arguments Représentation texte d'une étiquette
+     * @param contexte  Contexte de la session de l'interpreteur LIR
+     * @throws InterpreteurException Si un arguments ne corresponds
+     *                               pas a une étiquette valide
+     * @throws NullPointerException  Si contexte ou argument est null
+     */
+    public InstructionProcedure(String arguments, Contexte contexte) {
+        super(arguments, contexte);
+        
+        final String ERREUR_ARG = "procedure attend une étiquette en argument";
+        
+        if(arguments.isBlank()) {
+            throw new InterpreteurException(ERREUR_ARG);
+        }
+        
+        debutProcedure = new Etiquette(arguments);
+    }
+
+    /* non javadoc
+     * @see interpreteurlir.motscles.instructions.Instruction#toString()
+     */
+    @Override
+    public String toString() {
+        return "procedure " + debutProcedure;
+    }
+    
+    /**
+     * Execution de l'instruction :
+     * Appel d'une procedure située à l'étiquette de l'instruction.
+     * L'appel s'empile sur le contexte appellant pour ce qui est du
+     * compteur ordinal.
+     * @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_REFERENCEMENT = "Le programme doit être référencé "
+                                            + "dans la classe commande";
+        
+        if (programmeGlobal == null) {
+            throw new RuntimeException(ERREUR_REFERENCEMENT);
+        }
+        
+        programmeGlobal.appelProcedure(debutProcedure);
+        return false;
+    }
+}
diff --git a/src/interpreteurlir/motscles/instructions/InstructionRetour.java b/src/interpreteurlir/motscles/instructions/InstructionRetour.java
new file mode 100644
index 0000000..af519ea
--- /dev/null
+++ b/src/interpreteurlir/motscles/instructions/InstructionRetour.java
@@ -0,0 +1,73 @@
+/**
+ * InstructionRetour.java                                        15 mai 2021
+ * IUT-Rodez info1 2020-2021, pas de droits, pas de copyrights
+ */
+package interpreteurlir.motscles.instructions;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.ExecutionException;
+import interpreteurlir.InterpreteurException;
+
+/**
+ * Instruction qui transfère l'exécution au numéro d'étiquette
+ * appelant (continue en séquence après l'instruction procedure qui à généré
+ * l'appel).
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ *
+ */
+public class InstructionRetour extends Instruction {
+
+    /**
+     * Initialise une procedure qui est sans argument
+     * @param arguments Argument de retour soit une chaine blanche ou vide
+     * @param contexte  Contexte de la session de l'interpreteur LIR
+     * @throws InterpreteurException Si arguments n'est pas une chaîne blanche
+     *                               ou vide.
+     * @throws NullPointerException  Si contexte ou argument est null
+     */
+    public InstructionRetour(String arguments, Contexte contexte) {
+        super(arguments, contexte);
+        
+        final String ERREUR_ARG = "L'instruction retour n'a pas d'arguments";
+        
+        if (!arguments.isBlank()) {
+            throw new InterpreteurException(ERREUR_ARG);
+        }
+    }
+
+    /* non javadoc
+     * @see interpreteurlir.motscles.instructions.Instruction#toString()
+     */
+    @Override
+    public String toString() {
+        return "retour";
+    }
+    
+    /**
+     * Execution de l'instruction :
+     * Retour d'une procédure en séquence après l'instruction procédure
+     * appelante.
+     * @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 Lorsque retour est exécuté alors qu'aucune
+     *                            Instruction procedure n'a été exécutée avant.
+     */
+    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);
+        }
+        
+        programmeGlobal.retourProcedure();
+        
+        return false;
+    }
+}
diff --git a/src/interpreteurlir/motscles/instructions/InstructionStop.java b/src/interpreteurlir/motscles/instructions/InstructionStop.java
new file mode 100644
index 0000000..c28510b
--- /dev/null
+++ b/src/interpreteurlir/motscles/instructions/InstructionStop.java
@@ -0,0 +1,67 @@
+/**
+ * InstructionStop.java                                             16 mai 2021
+ * IUT info1 2020-2021, pas de copyright, aucun droit
+ */
+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
+ * LIR. Aucune ligne de code portant une étiquette supérieure ne sera donc lue.
+ * L'usage de cette instruction en ligne de commande directe n'a aucun effet.
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+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";
+    /**
+     * Initialise cette instruction stop à partir des arguments, du contexte
+     * et du programme passés en paramètres. Cette instruction ne modifie que
+     * le programme. Si arguments n'est pas vide, une exception sera levée.
+     * @param arguments doit être vide
+     * @param contexte global de la session de l'interpréteur
+     * @throws InterpreteurException si arguments non vide
+     */
+    public InstructionStop(String arguments, Contexte contexte) {
+        super(arguments, contexte);
+        
+        if (!arguments.isBlank())
+            throw new InterpreteurException(ERREUR_ARGUMENTS);
+    }
+
+    /*
+     * Non - javadoc
+     * @see interpreteurlir.motscles.instructions.Instruction#executer()
+     */
+    @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);
+        }
+        
+        programmeGlobal.stop();
+        return false;
+    }
+
+    /*
+     * Non - javadoc
+     * @see interpreteurlir.motscles.instructions.Instruction#toString()
+     */
+    @Override
+    public String toString() {
+        return "stop";
+    }
+}
diff --git a/src/interpreteurlir/motscles/instructions/InstructionVaen.java b/src/interpreteurlir/motscles/instructions/InstructionVaen.java
new file mode 100644
index 0000000..a4f43cc
--- /dev/null
+++ b/src/interpreteurlir/motscles/instructions/InstructionVaen.java
@@ -0,0 +1,72 @@
+/**
+ * InstructionVaen.java                                        15 mai 2021
+ * IUT-Rodez info1 2020-2021, pas de droits, pas de copyrights
+ */
+package interpreteurlir.motscles.instructions;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.programmes.Etiquette;
+
+/**
+ * Instruction qui transfère l'execution au numéro étiquette spécifié.
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ *
+ */
+public class InstructionVaen extends Instruction {
+
+    /** Etiquette à laquelle le programme doit se rendre */
+    private Etiquette etiquette;
+    
+    /** 
+     * Initialise un saut de ligne avec une étiquette en argument.
+     * @param arguments Etiquette à laquelle le programme doit se rendre
+     * @param contexte  Contexte de la session de l'interpreteur LIR
+     */
+    public InstructionVaen(String arguments, Contexte contexte) {
+        super(arguments, contexte);
+        
+        final String ERREUR_ARG = "vaen attend une étiquette en argument";
+        
+        if (arguments.isBlank()) {
+            throw new InterpreteurException(ERREUR_ARG);
+        }
+        
+        this.etiquette = new Etiquette(arguments);
+    }
+
+    /* non javadoc - 
+     * @see interpreteurlir.motscles.instructions.Instruction#toString()
+     * */
+    @Override
+    public String toString() {
+        return "vaen " + etiquette;
+    }
+
+    /**
+     * 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.
+     * @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";
+        
+        if (programmeGlobal == null) {
+            throw new RuntimeException(ERREUR);
+        }
+        
+        programmeGlobal.vaen(etiquette);
+        
+        return false;
+    }
+
+}
diff --git a/src/interpreteurlir/motscles/instructions/InstructionVar.java b/src/interpreteurlir/motscles/instructions/InstructionVar.java
index c146ed2..0f88fa4 100644
--- a/src/interpreteurlir/motscles/instructions/InstructionVar.java
+++ b/src/interpreteurlir/motscles/instructions/InstructionVar.java
@@ -23,7 +23,8 @@ import interpreteurlir.expressions.ExpressionChaine;
 public class InstructionVar extends Instruction {
 
     /**
-     * TODO comment initial state of the object
+     * Initialise une instruction var à partir de arguments.
+     * Le contexte sera modifié à l'exécution dde l'instruction.
      * @param arguments expression à exécuter
      * @param contexte global de l'interpréteur
      */
diff --git a/src/interpreteurlir/motscles/instructions/tests/TestInstructionAffiche.java b/src/interpreteurlir/motscles/instructions/tests/TestInstructionAffiche.java
new file mode 100644
index 0000000..ba1d0c5
--- /dev/null
+++ b/src/interpreteurlir/motscles/instructions/tests/TestInstructionAffiche.java
@@ -0,0 +1,108 @@
+/**
+ * TestInstructionAffiche.java                                      13 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.ExecutionException;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.expressions.Expression;
+import interpreteurlir.motscles.instructions.InstructionAffiche;
+
+
+/**
+ * Tests unitaires de l'instruction affiche, avec et sans arguments.
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class TestInstructionAffiche {
+    
+    /** Contexte d'execution pour jeux de tests */
+    private static final Contexte CONTEXTE_GBL = new Contexte();
+    
+    /** Jeu données valides pour test de InstructionAffiche */
+    private static final InstructionAffiche[] FIXTURE = {
+        new InstructionAffiche("", CONTEXTE_GBL),
+        new InstructionAffiche("   ", CONTEXTE_GBL),
+        new InstructionAffiche("\"Hello World !!!\"", CONTEXTE_GBL),
+        new InstructionAffiche("3 + 3", CONTEXTE_GBL),
+        new InstructionAffiche("marcel", CONTEXTE_GBL),
+        new InstructionAffiche("marcel + -3", CONTEXTE_GBL),
+        new InstructionAffiche("$fraysse", CONTEXTE_GBL),
+        new InstructionAffiche("$sanchis + \"coucou\"", CONTEXTE_GBL),
+        new InstructionAffiche("\"300000000000000000 ça passe\"", CONTEXTE_GBL)
+    };
+    
+    /** 
+     * Tests unitaires de 
+     * {@link InstructionAffiche#InstructionAffiche(String, Contexte)} 
+     */
+    public static void testInstructionAffiche() {
+        
+        final String[] INVALIDES = {
+            "a = b + c",
+            "3 +",
+            "une chaine de plus de soixtante quinze caractères ne devrait pas"
+            + "pouvoir s'afficher parce qu'elle est trop longue !",
+            "30000000000000000000000",
+            "12aveyron",
+            "$aveyron + 12"
+        };
+        
+        Expression.referencerContexte(CONTEXTE_GBL);
+        System.out.println("Exécution du test de InstructionAffiche(String"
+                           + ", Contexte)");
+        for (String argInvalide : INVALIDES) {
+            try {
+                new InstructionAffiche(argInvalide, CONTEXTE_GBL);
+                echec();
+            } catch (InterpreteurException | ExecutionException lancee) {
+                // Empty body
+            }
+        }
+    }
+    
+    /**
+     * Tests unitaires de {@link InstructionAffiche#executer()}
+     */
+    public static void testExecuter() {
+        
+        System.out.println("Exécution du test de executer()\nTEST VISUEL SUR "
+                           + "CONSOLE :");
+        
+        Expression.referencerContexte(CONTEXTE_GBL);
+        for (InstructionAffiche aLancer : FIXTURE)
+            aLancer.executer();
+        
+        System.out.println();
+    }
+    
+    /**
+     * Tests unitaires de {@link InstructionAffiche#toString()}
+     */
+    public static void testToString() {
+        
+        final String[] ATTENDUS = {
+            "affiche",
+            "affiche",
+            "affiche \"Hello World !!!\"",
+            "affiche 3 + 3",
+            "affiche marcel",
+            "affiche marcel + -3",
+            "affiche $fraysse",
+            "affiche $sanchis + \"coucou\"",
+            "affiche \"300000000000000000 ça passe\""
+        };
+        
+        System.out.println("Exécution du test de toString()");
+        for (int i = 0 ; i < FIXTURE.length ; i++) {
+            assertTrue(FIXTURE[i].toString().compareTo(ATTENDUS[i]) == 0);
+        }
+    }
+}
diff --git a/src/interpreteurlir/motscles/instructions/tests/TestInstructionEntre.java b/src/interpreteurlir/motscles/instructions/tests/TestInstructionEntre.java
new file mode 100644
index 0000000..b7dd480
--- /dev/null
+++ b/src/interpreteurlir/motscles/instructions/tests/TestInstructionEntre.java
@@ -0,0 +1,121 @@
+/**
+ * TestInstructionEntre.java                              13 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.motscles.instructions.tests;
+
+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.*;
+/** 
+ * Test unitaire de {@link InstructionEntre}
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class TestInstructionEntre {
+    
+    /**
+     * Contexte pour les tests
+     */
+    private final Contexte CONTEXTE_GLB = new Contexte();
+    
+    /**
+     * Jeux de données de instructionEntre valides
+     */
+    private InstructionEntre[] fixture = { 
+            new InstructionEntre("$chaine     ", CONTEXTE_GLB),
+            new InstructionEntre("     $toto", CONTEXTE_GLB),
+            new InstructionEntre("\t  entier  ", CONTEXTE_GLB),
+            new InstructionEntre("resultat", CONTEXTE_GLB),
+    };
+
+    /** 
+     * Test unitaire de 
+     * {@link InstructionEntre#InstructionEntre(String, Contexte)}
+     */
+    public void testInstructionEntreStringContexte() {
+        
+        System.out.println("\tExécution du test de "
+                + "InstructionEntre#InstructionEntre(String, Contexte)");
+        
+        final Contexte CONTEXTE = new Contexte();
+        
+        final String[] ARGS_INVALIDES = { 
+                "", 
+                "$hhjdkeliyehozrbnjkm236khl749k",
+                "$chaine = $toto + \"\"",
+                "entier/2",
+                "45"
+        };
+        
+        
+        for (String arg : ARGS_INVALIDES) {
+            
+            try {
+                new InstructionEntre(arg, CONTEXTE);
+                echec();
+                
+            } catch (InterpreteurException lancee) {
+            }
+            
+        }
+        
+        try {
+            new InstructionEntre("$chaine     ", CONTEXTE);
+            new InstructionEntre("     $toto", CONTEXTE);
+            new InstructionEntre("\t  entier  ", CONTEXTE);
+            new InstructionEntre("resultat", CONTEXTE);
+        } catch (InterpreteurException lancee) {
+            echec();
+        }
+    }
+    
+    /**
+     * Test unitaire de {@link InstructionEntre#toString()}
+     */
+    public void testToString() {
+        
+        final String[] TEXTE_ATTENDU = { 
+            "entre $chaine", "entre $toto", "entre entier", "entre resultat"
+        };
+        
+        System.out.println("\tExécution du test de "
+                           + "InstructionEntre#toString()");
+        
+        for (int numTest = 0 ; numTest < TEXTE_ATTENDU.length ; numTest++) {
+            assertEquivalence(TEXTE_ATTENDU[numTest],
+                              fixture[numTest].toString());
+        }
+        
+        
+        
+    }
+    
+    /**
+     * Test unitaire de {@link InstructionEntre#executer()}
+     */
+    public void testExecuter() {
+        System.out.println("Execution du test de InstructionEntre#executer()");
+        
+        for (InstructionEntre entre : fixture) {
+            
+            System.out.println("? " + entre);
+            try {
+                assertFalse(entre.executer());
+                System.out.println("ok");
+            } catch (ExecutionException lancee) {
+                System.err.println("nok : " + lancee.getMessage());
+            }
+        }
+        System.out.println("Contexte : \n" + CONTEXTE_GLB);
+    }
+    
+
+}
diff --git a/src/interpreteurlir/motscles/instructions/tests/TestInstructionProcedure.java b/src/interpreteurlir/motscles/instructions/tests/TestInstructionProcedure.java
new file mode 100644
index 0000000..b648852
--- /dev/null
+++ b/src/interpreteurlir/motscles/instructions/tests/TestInstructionProcedure.java
@@ -0,0 +1,142 @@
+/**
+ * TestInstructionProcedure.java                                        15 mai 2021
+ * IUT-Rodez info1 2020-2021, pas de droits, pas de copyrights
+ */
+package interpreteurlir.motscles.instructions.tests;
+
+import interpreteurlir.motscles.Commande;
+import interpreteurlir.motscles.instructions.InstructionProcedure;
+import interpreteurlir.motscles.instructions.InstructionVar;
+import interpreteurlir.Contexte;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.donnees.IdentificateurEntier;
+import interpreteurlir.expressions.Expression;
+import interpreteurlir.programmes.*;
+
+import static info1.outils.glg.Assertions.*;
+
+import info1.outils.glg.TestException;
+
+/**
+ * Tests unitaires de {@link InstructionProcedure}
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ *
+ */
+public class TestInstructionProcedure {
+    
+    /** Contexte global pour les tests */
+    private final Contexte CONTEXTE = new Contexte();
+    
+    /** Jeu de donnée d'InstructionProcedure valides */
+    private final InstructionProcedure[] FIXTURE = {
+            new InstructionProcedure("    1    ", CONTEXTE),
+            new InstructionProcedure("    10", CONTEXTE),
+            new InstructionProcedure("5    ", CONTEXTE),
+            new InstructionProcedure("1549", CONTEXTE),
+            new InstructionProcedure("99999", CONTEXTE)
+    };
+    
+    /** Programme utilisé dans les tests */
+    private final Programme PROG_REFERENCE = new Programme(); 
+    
+    /**
+     * Tests unitaires de
+     * {@link InstructionProcedure#InstructionProcedure(String, Contexte)}
+     */
+    public void testInstructionProcedureStringContexte() {
+        
+        System.out.println("\tExecution du test de "
+                           + "InstructionProcedure"
+                           + "#InstructionProcedure(String, Contexte)");
+        
+        final String[] ARGS_INVALIDES = {
+                /* Sans arguments */
+                "",
+                "\t",
+                "      ",
+                "\n",
+                
+                /* Arguments invalides */
+                "LETTRE",
+                "6messages",
+                "-5",
+                "100000"
+        };
+        
+        for (int i = 0 ; i < ARGS_INVALIDES.length ; i++) {
+            try {
+                new InstructionProcedure(ARGS_INVALIDES[i], CONTEXTE);
+                echec();
+            } catch (InterpreteurException lancee) {
+                // Test OK
+            }
+        }
+        
+        try {
+            new InstructionProcedure("    1    ", CONTEXTE);
+            new InstructionProcedure("    10", CONTEXTE);
+            new InstructionProcedure("5    ", CONTEXTE);
+            new InstructionProcedure("1549", CONTEXTE);
+            new InstructionProcedure("99999", CONTEXTE);
+        } catch (InterpreteurException e) {
+            echec();
+        }
+    }
+    
+    /**
+     * Tests unitaires de {@link InstructionProcedure#toString()}
+     */
+    public void testToString() {
+        System.out.println("\tExecution du test de "
+                           + "InstructionProcedure#toString()");
+        
+        final String[] FORMAT_ATTENDU = {
+                "procedure 1",
+                "procedure 10",
+                "procedure 5",
+                "procedure 1549",
+                "procedure 99999",
+        };
+        
+        for (int i = 0 ; i < FORMAT_ATTENDU.length ; i++) {
+            assertEquivalence(FORMAT_ATTENDU[i], FIXTURE[i].toString());
+        }
+    }
+    
+    /**
+     * Tests unitaires de {@link InstructionProcedure#executer()}
+     */
+    public void testExecuter() {
+        System.out.println("\tExecution du test de "
+                           + "InstructionProcedure#executer()");
+        
+        for(InstructionProcedure instruction : FIXTURE) {
+            try {
+                instruction.executer();
+                echec();
+            } catch (RuntimeException e) {
+                if (e instanceof TestException) {
+                    echec();
+                }
+                // Test OK
+            }
+        }
+        
+        Commande.referencerProgramme(PROG_REFERENCE);
+        Expression.referencerContexte(CONTEXTE);
+        
+        PROG_REFERENCE.ajouterLigne(new Etiquette(3),
+                                    new InstructionVar("test=5", CONTEXTE));
+        PROG_REFERENCE.ajouterLigne(new Etiquette(4), FIXTURE[1]);
+        PROG_REFERENCE.ajouterLigne(new Etiquette(5),
+                                    new InstructionVar("test=-1", CONTEXTE));
+        
+        PROG_REFERENCE.lancer();
+        assertEquivalence(CONTEXTE.lireValeurVariable(
+                          new IdentificateurEntier("test")).getValeur(), 5);
+    }
+}
diff --git a/src/interpreteurlir/motscles/instructions/tests/TestInstructionRetour.java b/src/interpreteurlir/motscles/instructions/tests/TestInstructionRetour.java
new file mode 100644
index 0000000..9aa4a10
--- /dev/null
+++ b/src/interpreteurlir/motscles/instructions/tests/TestInstructionRetour.java
@@ -0,0 +1,145 @@
+/**
+ * TestInstructionRetour.java                                        15 mai 2021
+ * IUT-Rodez info1 2020-2021, pas de droits, pas de copyrights
+ */
+package interpreteurlir.motscles.instructions.tests;
+
+import interpreteurlir.motscles.Commande;
+import interpreteurlir.motscles.instructions.InstructionProcedure;
+import interpreteurlir.motscles.instructions.InstructionRetour;
+import interpreteurlir.motscles.instructions.InstructionVar;
+import interpreteurlir.programmes.Etiquette;
+import interpreteurlir.programmes.Programme;
+import interpreteurlir.Contexte;
+import interpreteurlir.ExecutionException;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.donnees.IdentificateurEntier;
+import interpreteurlir.expressions.Expression;
+
+import static info1.outils.glg.Assertions.*;
+
+import info1.outils.glg.TestException;
+
+/**
+ * Tests unitaires de {@link InstructionRetour}
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ *
+ */
+public class TestInstructionRetour {
+    
+    /** Contexte global pour les tests */
+    private final Contexte CONTEXTE = new Contexte();
+    
+    /** Programme utilisé dans les tests */
+    private final Programme PROG_REFERENCE = new Programme();
+    
+    /** Jeu de donnée d'InstructionRetour valides */
+    private final InstructionRetour[] FIXTURE = {
+            new InstructionRetour("", CONTEXTE),
+            new InstructionRetour("   ", CONTEXTE),
+            new InstructionRetour("\t", CONTEXTE),
+            new InstructionRetour("\t   ", CONTEXTE)
+    };
+    
+    /**
+     * Tests unitaires de
+     * {@link InstructionRetour#InstructionRetour(String, Contexte)}
+     */
+    public void testInstructionRetourStringContexte() {
+        System.out.println("\t Exécution du test de "
+                + "InstructionRetour#InstructionRetour(String, Contexte)");
+        
+        final String[] ARGS_INVALIDES = {
+                "    a    ",
+                "bonjour bonsoir",
+                "513",
+                "@!?/",
+                "^p65Na@"
+        };
+        
+        for (int i = 0 ; i < ARGS_INVALIDES.length ; i++) {
+            try {
+                new InstructionRetour(ARGS_INVALIDES[i], CONTEXTE);
+                echec();
+            } catch (InterpreteurException lancee) {
+                // Test OK
+            }
+        }
+        
+        try {
+            new InstructionRetour("", CONTEXTE);
+            new InstructionRetour("   ", CONTEXTE);
+            new InstructionRetour("\t", CONTEXTE);
+            new InstructionRetour("\t   ", CONTEXTE);
+        } catch (InterpreteurException lancee) {
+            echec();
+        }
+    }
+    
+    /**
+     * Tests unitaires de {@link InstructionRetour#toString()}
+     */
+    public void testToString() {
+        System.out.println("\tExecution du test de "
+                           + "InstructionRetour#toString()");
+        
+        for (int i = 0 ; i < FIXTURE.length ; i++) {
+            assertEquivalence("retour", FIXTURE[i].toString());
+        }
+    }
+    
+    /**
+     * Tests unitaires de {@link InstructionRetour#executer()}
+     */
+    public void testExecuter() {
+        System.out.println("\tExecution du test de "
+                           + "InstructionRetour#executer()");
+        
+        for(InstructionRetour instruction : FIXTURE) {
+            try {
+                instruction.executer();
+                echec();
+            } catch (RuntimeException e) {
+                if (e instanceof TestException) {
+                    echec();
+                }
+                // Test OK
+            }
+        }
+        
+        Commande.referencerProgramme(PROG_REFERENCE);
+        Expression.referencerContexte(CONTEXTE);
+        
+        /* Test retour procedure invalide */
+        PROG_REFERENCE.ajouterLigne(new Etiquette(1), FIXTURE[0]);
+        PROG_REFERENCE.ajouterLigne(new Etiquette(4),
+                                    new InstructionProcedure("1", CONTEXTE));
+        PROG_REFERENCE.ajouterLigne(new Etiquette(10), FIXTURE[1]);
+        
+        try {
+            PROG_REFERENCE.lancer(new Etiquette(2));
+            echec();
+        } catch (ExecutionException lancee) {
+            // Test OK
+        }
+        
+        PROG_REFERENCE.raz();
+        
+        /* Tests retour procedure valide */
+        PROG_REFERENCE.ajouterLigne(new Etiquette(1),
+                                    new InstructionVar("test=5", CONTEXTE));
+        PROG_REFERENCE.ajouterLigne(new Etiquette(2), FIXTURE[0]);
+        PROG_REFERENCE.ajouterLigne(new Etiquette(3),
+                                    new InstructionVar("test=-1", CONTEXTE));
+        PROG_REFERENCE.ajouterLigne(new Etiquette(4),
+                                    new InstructionProcedure("1", CONTEXTE));
+        
+        PROG_REFERENCE.lancer(new Etiquette(3));
+        assertEquivalence(CONTEXTE.lireValeurVariable(
+                          new IdentificateurEntier("test")).getValeur(), 5);
+    }
+}
diff --git a/src/interpreteurlir/motscles/instructions/tests/TestInstructionStop.java b/src/interpreteurlir/motscles/instructions/tests/TestInstructionStop.java
new file mode 100644
index 0000000..c689480
--- /dev/null
+++ b/src/interpreteurlir/motscles/instructions/tests/TestInstructionStop.java
@@ -0,0 +1,91 @@
+/**
+ * TestInstructionStop.java                                             16 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.expressions.Expression;
+import interpreteurlir.motscles.Commande;
+import interpreteurlir.motscles.instructions.InstructionAffiche;
+import interpreteurlir.motscles.instructions.InstructionStop;
+import interpreteurlir.programmes.Etiquette;
+import interpreteurlir.programmes.Programme;
+
+/**
+ * Tests unitaires de l'instruction stop de l'interpréteur LIR.
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class TestInstructionStop {
+    
+    /** Contexte d'exécution nécessaire à instanciation */
+    private static final Contexte CONTEXTE_TESTS = new Contexte();
+    
+    /** Instruction stop valide */
+    public static final InstructionStop[] FIXTURE = {
+            new InstructionStop("", CONTEXTE_TESTS),
+            new InstructionStop("\t", CONTEXTE_TESTS),
+            new InstructionStop(" ", CONTEXTE_TESTS)
+    };
+    /** Tests du constructeur */
+    public static void testInstructionStop() {
+        
+        final String[] INVALIDES = {
+            "coucou",
+            " Bonjour",
+            null,
+            "entier = 2 + 3"
+        };
+        
+        System.out.println("Exécution du test de InstructionStop"
+                           + "(String, Contexte)");
+        for (String aTester : INVALIDES) {
+            try {
+                new InstructionStop(aTester, CONTEXTE_TESTS);
+                echec();
+            } catch (InterpreteurException | NullPointerException e) {
+                // Empty block
+            }
+        }
+    }
+    
+    /** Test de executer() */
+    public static void testExecuter() {
+        Programme pgmTest = new Programme();
+        System.out.println("Exécution du test de executer()\ntestVisuel\n");
+        Commande.referencerProgramme(pgmTest);
+        Expression.referencerContexte(CONTEXTE_TESTS);
+        pgmTest.ajouterLigne(new Etiquette(10), 
+                new InstructionAffiche("Bonjour", CONTEXTE_TESTS));
+        pgmTest.ajouterLigne(new Etiquette(20), 
+                new InstructionAffiche("Comment", CONTEXTE_TESTS));
+        pgmTest.ajouterLigne(new Etiquette(30), 
+                new InstructionAffiche("Allez", CONTEXTE_TESTS));
+        pgmTest.ajouterLigne(new Etiquette(40), 
+                new InstructionAffiche("Vous", CONTEXTE_TESTS));
+        pgmTest.ajouterLigne(new Etiquette(45), 
+                new InstructionStop("", CONTEXTE_TESTS));
+        pgmTest.ajouterLigne(new Etiquette(50), 
+                new InstructionAffiche("foobar", CONTEXTE_TESTS));
+        System.out.println(pgmTest);
+        System.out.println("lancement du programme : ne doit pas "
+                           + "afficher foobar");
+        pgmTest.lancer();
+    }
+    
+    /** Tests de toString() */
+    public static void testToString() {
+        
+        final String ATTENDUE = "stop";
+        System.out.println("Exécution du test de toString()");
+        for (InstructionStop valide : FIXTURE)
+             assertTrue(valide.toString().compareTo(ATTENDUE) == 0);
+    }
+}
diff --git a/src/interpreteurlir/motscles/instructions/tests/TestInstructionVaen.java b/src/interpreteurlir/motscles/instructions/tests/TestInstructionVaen.java
new file mode 100644
index 0000000..760335a
--- /dev/null
+++ b/src/interpreteurlir/motscles/instructions/tests/TestInstructionVaen.java
@@ -0,0 +1,157 @@
+/**
+ * TestInstructionVaen.java                                        15 mai 2021
+ * IUT-Rodez info1 2020-2021, pas de droits, pas de copyrights
+ */
+package interpreteurlir.motscles.instructions.tests;
+
+import interpreteurlir.motscles.Commande;
+import interpreteurlir.motscles.instructions.InstructionAffiche;
+import interpreteurlir.motscles.instructions.InstructionVaen;
+import interpreteurlir.programmes.Etiquette;
+import interpreteurlir.programmes.Programme;
+import interpreteurlir.Contexte;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.expressions.Expression;
+
+import static info1.outils.glg.Assertions.*;
+
+import info1.outils.glg.TestException;
+
+/** 
+ * Tests unitaires de {@link InstructionVaen}
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ *
+ */
+public class TestInstructionVaen {
+
+    /** Contexte global pour les tests */
+    private final Contexte CONTEXTE = new Contexte();
+
+    /** Programme utilisé dans les tests */
+    private final Programme PROG_REFERENCE = new Programme();
+
+    /** Jeu de donnée d'InstructionRetour valides */
+    private final InstructionVaen[] FIXTURE = {
+            new InstructionVaen("10", CONTEXTE),
+            new InstructionVaen("9", CONTEXTE),
+            new InstructionVaen("20", CONTEXTE),
+            new InstructionVaen("70", CONTEXTE),
+            new InstructionVaen("40", CONTEXTE),
+    };
+
+    /**
+     * Tests unitaires de
+     * {@link InstructionVaen#InstructionVaen(String, Contexte)}
+     */
+    public void testInstructionVaenStringContexte() {
+        System.out.println("\tExecution du test de "
+                + "InstructionVaen#InstructionVaen(String, Contexte)");
+        
+        final String[] ARGS_INVALIDES = {
+                "greuuuuuu",
+                " motus 5800",
+                "100000",
+                "-4",
+                "$$$$£££"
+        };
+
+        Expression.referencerContexte(CONTEXTE);
+
+        /* Cas invalides */
+        for (int i = 0; i < ARGS_INVALIDES.length; i++) {
+            try {
+                new InstructionVaen(ARGS_INVALIDES[i], CONTEXTE);
+                echec();
+            } catch (InterpreteurException lancee) {
+                // Test OK
+            }
+        }
+        
+        /* Cas Valides */
+        try {
+            new InstructionVaen("10", CONTEXTE);
+            new InstructionVaen("9", CONTEXTE);
+            new InstructionVaen("20", CONTEXTE);
+            new InstructionVaen("70", CONTEXTE);
+            new InstructionVaen("40", CONTEXTE);
+        } catch (InterpreteurException lancee) {
+            echec();
+        }
+    }
+
+    /**
+     * Tests unitaires de {@link InstructionVaen#toString()}
+     */
+    public void testToString() {
+        System.out.println("\tExecution du test de "
+                + "InstructionVaen#toString()");
+        
+        final String[] FORMAT_ATTENDU = {
+                "vaen 10",
+                "vaen 9",
+                "vaen 20",
+                "vaen 70",
+                "vaen 40"
+        };
+        
+        for (int i = 0 ; i < FORMAT_ATTENDU.length ; i++) {
+            assertEquivalence(FORMAT_ATTENDU[i], FIXTURE[i].toString());
+        }
+    }
+
+    /**
+     * Tests unitaires de {@link InstructionVaen#executer()}
+     */
+    public void testExecuter() {
+        System.out.println("\tExecution du test de "
+                + "InstructionVaen#executer()");
+        
+        /* Cas invalide : où le programme global est vide */
+        for(InstructionVaen instruction : FIXTURE) {
+            try {
+                instruction.executer();
+                echec();
+            } catch (RuntimeException e) {
+                if (e instanceof TestException) {
+                    echec();
+                }
+                // Test OK
+            }
+        }
+        
+        /* Cas valide */
+        Commande.referencerProgramme(PROG_REFERENCE);
+        Expression.referencerContexte(CONTEXTE);
+        
+        System.out.println("Test visuel : Ne doit pas afficher "
+                           + "les étiquettes (25, 31, 40 )");
+        /* 1,10,13 -> 78, 89 (saute 25, 31, 40) */
+        PROG_REFERENCE.ajouterLigne(new Etiquette(1),
+                new InstructionAffiche("\"1 \"", CONTEXTE));
+        PROG_REFERENCE.ajouterLigne(new Etiquette(10),
+                new InstructionAffiche("\"10 \"", CONTEXTE));
+        PROG_REFERENCE.ajouterLigne(new Etiquette(13),
+                new InstructionAffiche("\"13 \"", CONTEXTE));
+
+        PROG_REFERENCE.ajouterLigne(new Etiquette(25),
+                new InstructionAffiche("\"25 \"", CONTEXTE));
+        PROG_REFERENCE.ajouterLigne(new Etiquette(31),
+                new InstructionAffiche("\"31 \"", CONTEXTE));
+        PROG_REFERENCE.ajouterLigne(new Etiquette(40),
+                new InstructionAffiche("\"40 \"", CONTEXTE));
+        PROG_REFERENCE.ajouterLigne(new Etiquette(78),
+                new InstructionAffiche("\"78 \"", CONTEXTE));
+        PROG_REFERENCE.ajouterLigne(new Etiquette(89),
+                new InstructionAffiche("\"89 \"", CONTEXTE));
+
+        PROG_REFERENCE.ajouterLigne(new Etiquette(14),
+                new InstructionVaen("78", CONTEXTE));
+                
+        PROG_REFERENCE.lancer();
+        System.out.println();
+    }
+}
diff --git a/src/interpreteurlir/motscles/instructions/tests/TestInstructionVar.java b/src/interpreteurlir/motscles/instructions/tests/TestInstructionVar.java
index 4ef8cb9..d0991ca 100644
--- a/src/interpreteurlir/motscles/instructions/tests/TestInstructionVar.java
+++ b/src/interpreteurlir/motscles/instructions/tests/TestInstructionVar.java
@@ -72,7 +72,7 @@ public class TestInstructionVar {
     }
     
     /**
-     * TODO comment method responsibilities
+     * Lancement des tests
      * @param args
      */
     public static void main(String[] args) {
diff --git a/src/interpreteurlir/motscles/tests/TestCommande.java b/src/interpreteurlir/motscles/tests/TestCommande.java
index 1afad62..f056649 100644
--- a/src/interpreteurlir/motscles/tests/TestCommande.java
+++ b/src/interpreteurlir/motscles/tests/TestCommande.java
@@ -7,7 +7,9 @@ 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}
@@ -26,6 +28,26 @@ public class TestCommande {
             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)}
      */
diff --git a/src/interpreteurlir/motscles/tests/TestCommandeEfface.java b/src/interpreteurlir/motscles/tests/TestCommandeEfface.java
new file mode 100644
index 0000000..7d0257a
--- /dev/null
+++ b/src/interpreteurlir/motscles/tests/TestCommandeEfface.java
@@ -0,0 +1,92 @@
+/**
+ * TestCommandeEfface.java                                           16 mai 2021
+ * IUT info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.motscles.tests;
+
+import static info1.outils.glg.Assertions.*;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.motscles.Commande;
+import interpreteurlir.motscles.CommandeEfface;
+import interpreteurlir.motscles.instructions.InstructionAffiche;
+import interpreteurlir.programmes.Etiquette;
+import interpreteurlir.programmes.Programme;
+
+/**
+ * Tests unitaires de la commande d'effacement de lignes de codes pour 
+ * l'interpréteur LIR.
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class TestCommandeEfface {
+    
+    /** Contexte pour tests */
+    public static final Contexte CONTEXTE_TESTS = new Contexte();
+    
+    /** Programme global pour tests */
+    public static final Programme PGM_TESTS = new Programme();
+    
+    /** Jeu de test valide */
+    public static final CommandeEfface[] FIXTURE = {
+        new CommandeEfface("1:99999", CONTEXTE_TESTS),
+        new CommandeEfface(" 1 : 99999 ", CONTEXTE_TESTS),
+        new CommandeEfface("99999 :1 ", CONTEXTE_TESTS),
+        new CommandeEfface("1 : 1", CONTEXTE_TESTS),
+        new CommandeEfface(" 250: 150 ", CONTEXTE_TESTS)
+    };
+    
+    /** Test du constructeur */
+    public static void testCommandeEfface() {
+        
+        final String[] INVALIDES = {
+            "",
+            "23 : ",
+            " : 15",
+            "coucou",
+            "50 : coucou",
+            "12.4: 24",
+            "-14 : 90",
+            "\'a\' : 99"
+        };
+        
+        System.out.println("Exé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 de executer() */
+    public static void testExecuter() {
+        
+        System.out.println("Exécution du test d'executer()\nTest visuel :");
+        Commande.referencerProgramme(PGM_TESTS);
+        PGM_TESTS.ajouterLigne(new Etiquette(10), 
+                new InstructionAffiche("Bonjour", CONTEXTE_TESTS));
+        PGM_TESTS.ajouterLigne(new Etiquette(20), 
+                new InstructionAffiche("Comment", CONTEXTE_TESTS));
+        PGM_TESTS.ajouterLigne(new Etiquette(30), 
+                new InstructionAffiche("Allez", CONTEXTE_TESTS));
+        PGM_TESTS.ajouterLigne(new Etiquette(40), 
+                new InstructionAffiche("Vous", CONTEXTE_TESTS));
+        PGM_TESTS.ajouterLigne(new Etiquette(50), 
+                new InstructionAffiche("foobar", CONTEXTE_TESTS));
+        System.out.println(PGM_TESTS);
+        
+        CommandeEfface effacement = new CommandeEfface("20:30", CONTEXTE_TESTS);
+        effacement.executer();
+        
+        System.out.println(PGM_TESTS);
+        
+    }
+}
diff --git a/src/interpreteurlir/motscles/tests/TestCommandeLance.java b/src/interpreteurlir/motscles/tests/TestCommandeLance.java
new file mode 100644
index 0000000..1f7abe7
--- /dev/null
+++ b/src/interpreteurlir/motscles/tests/TestCommandeLance.java
@@ -0,0 +1,138 @@
+/**
+ * TestCommandeLance.java                                        15 mai 2021
+ * IUT-Rodez info1 2020-2021, pas de droits, pas de copyrights
+ */
+package interpreteurlir.motscles.tests;
+
+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.*;
+
+import info1.outils.glg.TestException;
+
+/** 
+ * Tests unitaires de la classe CommandeLance
+ * 
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class TestCommandeLance {
+    
+    private Contexte contexteTest = new Contexte();
+    private Programme programmeTest = new Programme();
+    
+    private final CommandeLance[] FIXTURE = {
+        new CommandeLance("", contexteTest),
+        new CommandeLance("10", contexteTest),
+        new CommandeLance("9", contexteTest),
+        new CommandeLance("20", contexteTest),
+        new CommandeLance("70", contexteTest),
+        new CommandeLance("40", contexteTest),
+    };
+    
+    private final String[] ARGS_VALIDES = {
+        "",
+        "10",
+        "9",
+        "20",
+        "70",
+        "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)}
+     */
+    public void testCommandeLance() {
+        
+        final String[] ARGS_INVALIDES = {
+            "greuuuuuu",
+            " motus 5800",
+            "100000",
+            "-4",
+            "$$$$£££"
+        };
+        
+        Expression.referencerContexte(contexteTest);
+        
+        for (int i = 0; i < ARGS_INVALIDES.length; i++) {
+            try {
+                new CommandeLance(ARGS_INVALIDES[i], contexteTest);
+                echec();
+            } catch (InterpreteurException lancee) {
+                // Test OK
+            }
+        }
+        
+        for (int i = 0 ; i < ARGS_VALIDES.length ; i++) {
+            try {
+                contexteTest.raz();
+                new CommandeLance(ARGS_VALIDES[i], contexteTest);
+            } catch (InterpreteurException lancee) {
+                echec();
+            }
+        }
+    }
+    
+    /**
+     * Test unitaire de {@link CommandeLance#executer()}
+     */
+    public void testExecuter() {
+        
+        //ecrireProgrammeTest();
+        Expression.referencerContexte(contexteTest);
+        
+        for (int i = 0 ; i < FIXTURE.length ; i++) {
+            try {
+                FIXTURE[i].executer();
+                echec();
+            } catch (RuntimeException lancee) {
+                if (lancee instanceof TestException) {
+                    echec();
+                }
+            }
+        }
+        
+        // Tests valides faits en intégration
+    }
+}
diff --git a/src/interpreteurlir/motscles/tests/TestCommandeListe.java b/src/interpreteurlir/motscles/tests/TestCommandeListe.java
new file mode 100644
index 0000000..67013de
--- /dev/null
+++ b/src/interpreteurlir/motscles/tests/TestCommandeListe.java
@@ -0,0 +1,142 @@
+/**
+ * TestCommandeListe.java                                        15 mai 2021
+ * IUT-Rodez info1 2020-2021, pas de droits, pas de copyrights
+ */
+package interpreteurlir.motscles.tests;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.expressions.Expression;
+import interpreteurlir.motscles.Commande;
+import interpreteurlir.motscles.CommandeListe;
+import interpreteurlir.motscles.instructions.Instruction;
+import interpreteurlir.motscles.instructions.InstructionVar;
+import interpreteurlir.programmes.Etiquette;
+import interpreteurlir.programmes.Programme;
+
+import static info1.outils.glg.Assertions.*;
+
+import info1.outils.glg.TestException;
+
+/** 
+ * Tests unitaires de la classe Commande liste
+ * 
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class TestCommandeListe {
+
+    private Programme programmeTest = new Programme();
+    private Contexte contexteTest = new Contexte();
+
+    private final CommandeListe[] FIXTURE = {
+            new CommandeListe("1:89", contexteTest),
+            new CommandeListe("13:30", contexteTest),
+            new CommandeListe("17:54", contexteTest),
+            new CommandeListe("40:108", contexteTest),
+    };
+    
+    private final String[] ARGS_VALIDES = {
+            "1:90",
+            "5:45",
+            "40:56"
+    };
+    
+    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 CommandeListe#CommandeListe(String, interpreteurlir.Contexte)}
+     */
+    public void testCommandeListe() {
+        
+        final String[] ARGS_INVALIDES = {
+            "agreu",
+            "0:0",
+            "-4:9",
+            "45:-8",
+            "78:12",
+            "1:",
+            ":4",
+            "1:100000"
+        };
+        
+        for (int i = 0; i < ARGS_INVALIDES.length; i++) {
+            try {
+                new CommandeListe(ARGS_INVALIDES[i], contexteTest);
+                echec();
+            } catch (InterpreteurException lancee) {
+                // Test OK
+            }
+        }
+        
+        for (int i = 0 ; i < ARGS_VALIDES.length ; i++) {
+            try {
+                new CommandeListe(ARGS_VALIDES[i], contexteTest);
+            } catch (InterpreteurException lancee) {
+                echec();
+            }
+        }
+    }
+    
+    /** 
+     * Test unitaire de {@link CommandeListe#executer()}
+     */
+    public void testExecuter() {
+        
+        for (int i = 0 ; i < FIXTURE.length ; i++) {
+            try {
+                FIXTURE[i].executer();
+                echec();
+            } catch (RuntimeException lancee) {
+                if (lancee instanceof TestException) {
+                    echec();
+                }
+                // Test OK
+            }
+        }
+
+        ecrireProgrammeTest();
+        Commande.referencerProgramme(programmeTest);
+        Expression.referencerContexte(contexteTest);
+        
+        for (int i = 0 ; i < FIXTURE.length ; i++) {
+            try {
+                FIXTURE[i].executer();
+            } catch (RuntimeException lancee) {
+                echec();
+            }
+        }
+    }
+     
+}
\ No newline at end of file
diff --git a/src/interpreteurlir/programmes/Etiquette.java b/src/interpreteurlir/programmes/Etiquette.java
new file mode 100644
index 0000000..5aa6539
--- /dev/null
+++ b/src/interpreteurlir/programmes/Etiquette.java
@@ -0,0 +1,99 @@
+/**
+ * Etiquette.java                              13 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.programmes;
+
+import interpreteurlir.InterpreteurException;
+
+/**
+ * Etiquette permettant de définir les ordres d'exécution 
+ * des instructions d'un programme.
+ * Le compteur ordinal pointe vers une étiquette.
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class Etiquette implements Comparable<Etiquette> {
+
+    /** Valeur minimale d'une étiquette */
+    public static final int VALEUR_ETIQUETTE_MIN = 1;
+    
+    /** Valeur maximale d'une étiquette */
+    public static final int VALEUR_ETIQUETTE_MAX = 99999;
+    
+    /** Message d'erreur pour une étiquette invalide */
+    private static final String MSG_INVALIDE = 
+            "valeur invalide pour une étiquette";
+    
+    /** valeur de cette étiquette */
+    private int valeur;
+    
+    /**
+     * Initialise une étiquette qui défini l'ordre d'exécution 
+     * d'une instruction à partir d'un entier
+     * @param valeur valeur de l'étiquette
+     * @throws InterpreteurException si valeur n'appartient pas 
+     *         à [ VALEUR_ETIQUETTE_MIN, VALEUR_ETIQUETTE_MAX ]
+     */
+    public Etiquette(int valeur) {
+        super();
+        if (valeur < VALEUR_ETIQUETTE_MIN || valeur > VALEUR_ETIQUETTE_MAX) {
+            throw new InterpreteurException(MSG_INVALIDE);
+        }
+        
+        this.valeur = valeur;
+    }
+    
+    /**
+     * Initialise une étiquette qui défini l'ordre d'exécution 
+     * d'une instruction à partir d'un entier dans une chaîne de texte
+     * @param valeur chaîne contenant la valeur de l'étiquette
+     * @throws InterpreteurException si l'entier de valeur n'appartient pas 
+     *         à [ VALEUR_ETIQUETTE_MIN, VALEUR_ETIQUETTE_MAX ]
+     */
+    public Etiquette(String valeur) {
+        super();
+        
+        int valeurEntiere;
+        
+        try {
+            valeurEntiere = Integer.valueOf(valeur.trim());
+        } catch (NumberFormatException | NullPointerException lancee) {
+            throw new InterpreteurException(MSG_INVALIDE);
+        }
+        
+        if (valeurEntiere < VALEUR_ETIQUETTE_MIN 
+                || valeurEntiere > VALEUR_ETIQUETTE_MAX) {
+            throw new InterpreteurException(MSG_INVALIDE);
+        }
+        
+        this.valeur = valeurEntiere;
+    }
+
+    /* non javadoc
+     * @see java.lang.Object#toString()
+     */
+    @Override
+    public String toString() {
+        return Integer.toString(valeur);
+    }
+
+    /**
+     * @return valeur de valeur
+     */
+    public int getValeur() {
+        return valeur;
+    }
+
+    /* non javadoc
+     * @see java.lang.Comparable#compareTo(java.lang.Object)
+     */
+    @Override
+    public int compareTo(Etiquette aComparer) {
+        return valeur - aComparer.valeur;
+    }  
+
+}
diff --git a/src/interpreteurlir/programmes/Programme.java b/src/interpreteurlir/programmes/Programme.java
new file mode 100644
index 0000000..e7ea785
--- /dev/null
+++ b/src/interpreteurlir/programmes/Programme.java
@@ -0,0 +1,279 @@
+/**
+ * Programme.java                                        14 mai 2021
+ * IUT-Rodez info1 2020-2021, pas de droits, pas de copyrights
+ */
+package interpreteurlir.programmes;
+
+import java.util.EmptyStackException;
+import java.util.Map;
+import java.util.Stack;
+import java.util.TreeMap;
+
+import interpreteurlir.ExecutionException;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.motscles.instructions.Instruction;
+
+import static interpreteurlir.programmes.Etiquette.VALEUR_ETIQUETTE_MAX;
+import static interpreteurlir.programmes.Etiquette.VALEUR_ETIQUETTE_MIN;
+
+/** 
+ * Enregistrement des lignes de code (instruction associée à une 
+ * étiquette) et gestion de l'exécution des lignes de code dans 
+ * l'ordre des étiquettes
+ * 
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class Programme {
+    
+    private static final String ERREUR_INTERVALLE = "erreur dans l'intervalle "
+                                                    + "d'étiquettes. "; 
+    
+    /** Pile LIFO pour la gestion des étiquettes */
+    private Stack<Etiquette> compteurOrdinnal;
+    
+    /** Détermine la poursuite d'exécution de ce programme */
+    private boolean enExecution;
+    
+    private TreeMap<Etiquette, Instruction> lignesCode;
+    
+    /** 
+     * Initialisation de ce programme sans lignes de code
+     * <p>
+     * 
+     */
+    public Programme() {
+        super();
+        lignesCode = new TreeMap<Etiquette, Instruction>();
+        enExecution = false;
+        compteurOrdinnal = new Stack<Etiquette>();
+        
+    }
+
+    /** 
+     * Remise à zero de ce programme
+     * <p>
+     * Vide ce programme de toute lignes de code (instruction associée
+     * à une étiquette)
+     */
+    public void raz() {
+        lignesCode.clear();
+        compteurOrdinnal.clear();
+    }
+
+    /** 
+     * Ajoute une ligne de code (instruction associée à une étiquette)
+     * à ce programme
+     * <p>
+     * Une ligne ajoutée à une même étiquette écrase le contenu associé
+     * à cette dernière
+     * 
+     * @param etiquette pour donner l'ordre d'exécution de ce programme
+     * @param instruction associée une étiquette à insérer dans ce 
+     *      programme
+     * @throws NullPointerException si l'étiquette ou l'instruction
+     *                              est nulle
+     */
+    public void ajouterLigne(Etiquette etiquette, Instruction instruction) {
+        if (etiquette == null || instruction == null) {
+            throw new NullPointerException();
+        }
+        
+        lignesCode.put(etiquette, instruction);
+    }
+
+    /* non javadoc
+     * @see java.lang.Object#toString()
+     */
+    @Override
+    public String toString() {
+        
+        Object[] tableauEtiquette 
+                = lignesCode.keySet().toArray();
+        
+        Object[] tableauInstruction
+                = lignesCode.values().toArray();
+        
+        StringBuilder aAfficher = new StringBuilder("");
+        
+        for (int i = 0; i < tableauEtiquette.length; i++) {
+            aAfficher.append(tableauEtiquette[i] + " " 
+                             + tableauInstruction[i] + '\n');
+        }
+        
+        return aAfficher.toString();
+    }
+
+    /** 
+     * Liste des lignes de code comprise entre les étiquettes de 
+     * début et les étiquettes de fin
+     * <p>
+     * S'il n'y aucune ligne de code dans l'intervalle, alors la
+     * chaîne renvoyée contient un message qui l'indique.
+     * 
+     * @param debut étiquette à partir de laquelle le programme 
+     *              est listé
+     * @param fin   dernière étiquette associée à son contenu à lister
+     * @return la représentation texte des lignes de code comprise 
+     *         entre les étiquettes de début et les étiquettes de fin
+     * @throws InterpreteurException si fin est strictement inférieur 
+     *                               à debut
+     */
+    public String listeBornee(Etiquette debut, Etiquette fin) {
+        
+        if (fin.compareTo(debut) < 0) {
+            throw new InterpreteurException(ERREUR_INTERVALLE);
+        }
+        
+        StringBuilder aAfficher = new StringBuilder("");
+        Etiquette cleCourante = debut;
+        Instruction instCourante = null;
+        Map.Entry<Etiquette, Instruction> entreeCourante;
+        boolean lignesRestantes;
+        
+        do {
+            entreeCourante = lignesCode.ceilingEntry(cleCourante);
+            lignesRestantes = entreeCourante != null;
+            
+            if (lignesRestantes) {
+                cleCourante = entreeCourante.getKey();
+                instCourante = entreeCourante.getValue();
+                lignesRestantes = cleCourante.compareTo(fin) <= 0;
+            }
+            
+            if (lignesRestantes) {
+                aAfficher.append(cleCourante + " " + instCourante + '\n');
+                cleCourante = new Etiquette(cleCourante.getValeur() + 1);
+            }
+        } while (lignesRestantes);
+        
+        return aAfficher.toString().equals("") 
+               ? "Aucune ligne de code dans cet intervalle.\n"
+               : aAfficher.toString();
+    }
+    
+    /** 
+     * Efface les lignes de code comprises entre les étiquettes debut
+     * et fin
+     *
+     * @param debut étiquette à partir de laquelle le programme 
+     *              est à effacer
+     * @param fin   dernière étiquette associée à son contenu à effacer
+     * @throws InterpreteurException si fin est strictement inférieur 
+     *                               à debut 
+     */
+    public void effacer(Etiquette debut, Etiquette fin) {
+        
+        if (fin.compareTo(debut) < 0) {
+            throw new InterpreteurException(ERREUR_INTERVALLE);
+        }
+        
+        Etiquette cleCourante = debut;
+        boolean lignesRestantes;
+        
+        do {
+            cleCourante = lignesCode.ceilingKey(cleCourante);
+            lignesRestantes = cleCourante != null 
+                              && cleCourante.compareTo(fin) <= 0;
+            if (lignesRestantes) {
+                lignesCode.remove(cleCourante);
+                cleCourante = new Etiquette(cleCourante.getValeur() + 1);
+            }
+        } while (lignesRestantes);
+    }
+    
+    /** 
+     * Arrête l'exécution du programme
+     */
+    public void stop() {
+        enExecution = false;
+    }
+    
+    /**
+     * Boucle d'exécution du programme
+     */
+    private void execution() {
+        Etiquette etiquetteCourante;
+        while (enExecution) {
+            etiquetteCourante = compteurOrdinnal.pop();
+            etiquetteCourante = lignesCode.ceilingKey(etiquetteCourante);
+            enExecution = etiquetteCourante != null 
+                && etiquetteCourante.getValeur() + 1 <= VALEUR_ETIQUETTE_MAX;
+            
+            if (enExecution) {
+                compteurOrdinnal.push(
+                        new Etiquette(etiquetteCourante.getValeur() + 1));
+                lignesCode.get(etiquetteCourante).executer();
+            }
+        }
+    }
+
+    /** 
+     * Lance l'exécution du programme à partir de l'étiquette
+     * passée en argument
+     * 
+     * @param etiquetteDepart étiquette à partir de laquelle
+     *                        l'exécution du programme est lancée
+     */
+    public void lancer(Etiquette etiquetteDepart) {
+        compteurOrdinnal.clear();
+        compteurOrdinnal.push(etiquetteDepart);
+        enExecution = true;
+        execution();
+    }
+    
+    /** 
+     * Lance l'exécution du programme à partir de l'étiquette
+     * la plus petite
+     */
+    public void lancer() {
+        lancer(new Etiquette(VALEUR_ETIQUETTE_MIN));
+    }
+    
+    /**
+     * Change le compteur ordinal avec l'étiquette argument
+     * @param destination étiquette où continuer l'exécution
+     */
+    public void vaen(Etiquette destination) {
+        if (!compteurOrdinnal.isEmpty()) {
+            compteurOrdinnal.pop();
+        }
+        compteurOrdinnal.push(destination);
+        enExecution = true;
+        execution();
+    }
+    
+    /** 
+     * Appel une procédure en empilant l'étiquette de départ dans
+     * le compteurOrdinal 
+     * @param depart étiquette du début de la procédure
+     */
+    public void appelProcedure(Etiquette depart) {
+        compteurOrdinnal.push(depart);
+    }
+    
+    /** 
+     * 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 "
+                                     + "procédure au préalable";
+        try {
+            compteurOrdinnal.pop();
+        } catch (EmptyStackException lancee) {
+            // empty body
+        }
+        
+        
+        if (compteurOrdinnal.isEmpty()) {
+            throw new ExecutionException(ERREUR_RETOUR);
+        }
+    }
+}
diff --git a/src/interpreteurlir/programmes/tests/TestEtiquette.java b/src/interpreteurlir/programmes/tests/TestEtiquette.java
new file mode 100644
index 0000000..6214ec0
--- /dev/null
+++ b/src/interpreteurlir/programmes/tests/TestEtiquette.java
@@ -0,0 +1,219 @@
+/**
+ * TestEtiquette.java                              13 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.programmes.tests;
+
+import static info1.outils.glg.Assertions.*;
+
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.programmes.Etiquette;
+
+/**
+ * Tests unitaires de {@link Etiquette}
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class TestEtiquette {
+
+    /** Jeu de données valides pour les tests */
+    private Etiquette[] fixture = {
+            new Etiquette(Etiquette.VALEUR_ETIQUETTE_MIN),
+            new Etiquette(10),
+            new Etiquette(15),
+            new Etiquette(8),
+            new Etiquette(18),
+            new Etiquette(1500),
+            new Etiquette(1501),
+            new Etiquette(Etiquette.VALEUR_ETIQUETTE_MAX),
+            new Etiquette("" +Etiquette.VALEUR_ETIQUETTE_MIN),
+            new Etiquette("   10"),
+            new Etiquette("15 "),
+            new Etiquette("8"),
+            new Etiquette("18"),
+            new Etiquette("1500  "),
+            new Etiquette("  1501   "),
+            new Etiquette("" + Etiquette.VALEUR_ETIQUETTE_MAX),
+    };
+    
+    /**
+     * Tests unitaires de {@link Etiquette#Etiquette(int)}
+     */
+    public void testEtiquetteInt() {
+        System.out.println("\tExécution du test de Etiquette#Etiquette(int)");
+        
+        final int[] INVALIDES = {
+                Integer.MIN_VALUE, -1, 0, 100000, Integer.MAX_VALUE
+        };
+        
+        for (int valeur : INVALIDES) {
+            try {
+                new Etiquette(valeur);
+                echec();
+            } catch (InterpreteurException lancee) {
+                
+            }
+        }
+        
+        try {
+            new Etiquette(Etiquette.VALEUR_ETIQUETTE_MIN);
+            new Etiquette(10);
+            new Etiquette(15);
+            new Etiquette(8);
+            new Etiquette(18);
+            new Etiquette(1500);
+            new Etiquette(1501);
+            new Etiquette(Etiquette.VALEUR_ETIQUETTE_MAX);
+        } catch (InterpreteurException lancee) {
+            echec();
+        }
+    }
+    
+    /**
+     * Tests unitaires de {@link Etiquette#Etiquette(String)}
+     */
+    public void testEtiquetteString() {
+        System.out.println("\tExécution du test de "
+                           + "Etiquette#Etiquette(String)");
+        
+        final String[] INVALIDES = {
+                null, "", "cinq",
+                "" + Integer.MIN_VALUE, "-1", "   0",
+                "100000   ", "" + Integer.MAX_VALUE
+        };
+        
+        for (String valeur : INVALIDES) {
+            try {
+                new Etiquette(valeur);
+                echec();
+            } catch (InterpreteurException lancee) {
+                
+            }
+        }
+        
+        try {
+            new Etiquette("" +Etiquette.VALEUR_ETIQUETTE_MIN);
+            new Etiquette("   10");
+            new Etiquette("15 ");
+            new Etiquette("8");
+            new Etiquette("18");
+            new Etiquette("1500  ");
+            new Etiquette("  1501   ");
+            new Etiquette("" + Etiquette.VALEUR_ETIQUETTE_MAX);
+        } catch (InterpreteurException lancee) {
+            echec();
+        }
+    }
+    
+    /**
+     * Tests unitaires de {@link Etiquette#toString()}
+     */
+    public void testToString() {
+        System.out.println("\tExécution du test de Etiquette#toString()");
+        
+        final String[] TEXTE_ATTENDU = {
+                "1",
+                "10",
+                "15",
+                "8",
+                "18",
+                "1500",
+                "1501",
+                "99999",
+                "1",
+                "10",
+                "15",
+                "8",
+                "18",
+                "1500",
+                "1501",
+                "99999",
+        };
+        
+        for (int numTest = 0 ; numTest < TEXTE_ATTENDU.length ; numTest++) {
+            assertEquivalence(fixture[numTest].toString(), 
+                              TEXTE_ATTENDU[numTest]);
+        }
+    }
+    
+    /**
+     * Tests unitaires de {@link Etiquette#getValeur()}
+     */
+    public void testGetValeur() {
+        System.out.println("\tExécution du test de Etiquette#getValeur()");
+        
+        final int[] VALEUR_ATTENDUE = {
+                1,
+                10,
+                15,
+                8,
+                18,
+                1500,
+                1501,
+                99999,
+                1,
+                10,
+                15,
+                8,
+                18,
+                1500,
+                1501,
+                99999,        
+        };
+        
+        for (int numTest = 0 ; numTest < VALEUR_ATTENDUE.length ; numTest++) {
+            assertEquivalence(fixture[numTest].getValeur(), 
+                              VALEUR_ATTENDUE[numTest]);
+        }
+    }
+    
+    /**
+     * Test unitaires de {@link Etiquette#compareTo(Etiquette)}
+     */
+    public void testCompareTo() {
+        final Etiquette[] CROISSANTS = {
+                new Etiquette(Etiquette.VALEUR_ETIQUETTE_MIN),
+                new Etiquette(8),
+                new Etiquette(10),
+                new Etiquette(15),
+                new Etiquette(18),
+                new Etiquette(1500),
+                new Etiquette(1501),
+                new Etiquette(Etiquette.VALEUR_ETIQUETTE_MAX),        
+        };
+        
+        System.out.println("\tExécution du test de "
+                           + "Etiquette#compareTo(Etiquette)");
+        
+        /** Test croissant */
+        for (int reference = 0 ; reference < CROISSANTS.length ; reference++) {
+            for (int numtest = reference + 1 ; 
+                    numtest < CROISSANTS.length ; 
+                    numtest++) {
+                assertTrue(CROISSANTS[reference].compareTo(
+                                                 CROISSANTS[numtest]) < 0);
+            }
+        }
+        
+        /** Test décroissant */
+        for (int reference = CROISSANTS.length - 1 ; 
+                reference > 0 ; 
+                reference--) {
+            
+            for (int numtest = reference - 1 ; 
+                    numtest >= 0 ; 
+                    numtest--) {
+                assertTrue(CROISSANTS[reference].compareTo(
+                                                 CROISSANTS[numtest]) > 0);
+            }
+        }
+        
+        Etiquette referenceEgalite = new Etiquette(666);
+        assertTrue(referenceEgalite.compareTo(referenceEgalite) == 0);
+        assertTrue(referenceEgalite.compareTo(new Etiquette("666")) == 0);
+    }
+
+}
diff --git a/src/interpreteurlir/programmes/tests/TestProgramme.java b/src/interpreteurlir/programmes/tests/TestProgramme.java
new file mode 100644
index 0000000..6674842
--- /dev/null
+++ b/src/interpreteurlir/programmes/tests/TestProgramme.java
@@ -0,0 +1,364 @@
+/**
+ * TestProgramme.java                                        14 mai 2021
+ * IUT-Rodez info1 2020-2021, pas de droits, pas de copyrights
+ */
+package interpreteurlir.programmes.tests;
+
+import interpreteurlir.programmes.*;
+import interpreteurlir.Contexte;
+import interpreteurlir.ExecutionException;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.expressions.Expression;
+import interpreteurlir.motscles.instructions.*;
+import static info1.outils.glg.Assertions.*;
+
+/** 
+ * Tests unitaires de {@link Programme}
+ * 
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class TestProgramme {
+    
+    private Programme programmeTest = new Programme();
+
+    private Contexte contexteTest = new Contexte();
+    
+    private final Etiquette[] JEU_ETIQUETTES = {
+        new Etiquette(1),
+        new Etiquette(10),
+        new Etiquette(13),
+        new Etiquette(5),
+        new Etiquette(31),
+        new Etiquette(40),
+        new Etiquette(5),
+        new Etiquette(89)
+    };
+    
+    private final Instruction[] JEU_INSTRUCTIONS = {
+        new InstructionVar("$toto = \"toto\"", contexteTest),
+        new InstructionVar("tata = 0 + 0", contexteTest),
+        new InstructionVar("$titi = \"titi\"", contexteTest),
+        new InstructionEntre("agreu", contexteTest),
+        new InstructionEntre("tutu", contexteTest),
+        new InstructionVar("entier = 93", contexteTest),
+        new InstructionVar("$agreuagreu = \"agreu\"", contexteTest),
+        new InstructionVar("$youpi = \"youpi lapin\"", contexteTest)
+    };
+    
+    private static 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) }
+    };
+    
+    private static final int DEBUT = 0;
+    private static final int   FIN = 1;
+    
+    private void ajoutLigne() {
+        for (int i = 0; i < JEU_ETIQUETTES.length; i++) {
+            programmeTest.ajouterLigne(JEU_ETIQUETTES[i], JEU_INSTRUCTIONS[i]);
+        }
+    }
+
+    /** 
+     * Test unitaire de {@link Programme#Programme()} 
+     */
+    public void testProgramme() {
+        System.out.println("\tExécution du test de Programme() : ");
+        
+        try {
+            new Programme();
+        } catch (Exception lancee) {
+            echec();
+        }
+    }
+
+    /** 
+     * Test unitaire de {@link Programme#ajouterLigne(Etiquette, Instruction)} 
+     */
+    public void testAjouterLigne() {
+        
+        final Etiquette[] ETIQUETTES_INVALIDES = {
+            null,
+            new Etiquette(1),
+            null,
+        };
+
+        final Instruction[] INSTRUCTIONS_INVALIDES = {
+                new InstructionEntre("janis", contexteTest),
+                null,
+                null
+        };
+        
+        System.out.println("\tExécution du test de ajouterLigne() : ");
+        
+        for (int i = 0; i < ETIQUETTES_INVALIDES.length; i++) {
+            try {
+                programmeTest.ajouterLigne(ETIQUETTES_INVALIDES[i], 
+                                           INSTRUCTIONS_INVALIDES[i]);
+                echec();
+            } catch (NullPointerException lancee) {
+                // Test OK
+            }
+        }
+        
+        for (int i = 0; i < JEU_ETIQUETTES.length; i++) {
+            try {
+                programmeTest.ajouterLigne(JEU_ETIQUETTES[i], 
+                                           JEU_INSTRUCTIONS[i]);
+            } catch (NullPointerException lancee) {
+                echec();
+            }
+        }
+    }
+    
+    /** 
+     * Test unitaire de {@link Programme#toString()}
+     */
+    public void testToString() {
+        
+        final String TEXTE_ATTENDU = "1 var $toto = \"toto\"\n"
+                                     + "5 var $agreuagreu = \"agreu\"\n"
+                                     + "10 var tata = 0 + 0\n"
+                                     + "13 var $titi = \"titi\"\n"
+                                     + "31 entre tutu\n"
+                                     + "40 var entier = 93\n"
+                                     + "89 var $youpi = \"youpi lapin\"\n";
+                
+        ajoutLigne();
+        System.out.println("\tExécution du test de toString() : ");
+        assertEquivalence(TEXTE_ATTENDU, programmeTest.toString());
+    }
+    
+    /** 
+     * Test unitaire de {@link Programme#raz()}
+     */
+    public void testRaz() {
+        
+        System.out.println("\tExécution du test de raz() : ");
+        
+        programmeTest.raz();
+        assertEquivalence(programmeTest.toString(), "");
+        
+        ajoutLigne();
+        programmeTest.raz();
+        assertEquivalence(programmeTest.toString(), "");
+    }
+   
+    /** 
+     * Test unitaire de {@link Programme#listeBornee(Etiquette, Etiquette)}
+     */
+    public void testListeBornee() {
+        
+        final String[] TEXTES_ATTENDUS = {
+            "Aucune ligne de code dans cet intervalle.\n",
+            "1 var $toto = \"toto\"\n"
+                    + "5 var $agreuagreu = \"agreu\"\n"
+                    + "10 var tata = 0 + 0\n"
+                    + "13 var $titi = \"titi\"\n"
+                    + "31 entre tutu\n"
+                    + "40 var entier = 93\n"
+                    + "89 var $youpi = \"youpi lapin\"\n",
+           "31 entre tutu\n",
+           "10 var tata = 0 + 0\n"
+                   + "13 var $titi = \"titi\"\n"
+                   + "31 entre tutu\n"
+                   + "40 var entier = 93\n",
+        };
+        
+        final Etiquette[][] BORNES_INVALIDES = {
+                { new Etiquette(8), new Etiquette(6) },
+                { new Etiquette(10000), new Etiquette(90) }
+        };
+        
+        ajoutLigne();
+        
+        System.out.println("\tExécution du test de listeBornee() : ");
+        
+        for (int i = 0; i < TEXTES_ATTENDUS.length; i++) {
+            assertEquivalence(TEXTES_ATTENDUS[i], 
+                              programmeTest.listeBornee(BORNES[i][DEBUT], 
+                                                        BORNES[i][FIN]));
+        }
+        
+        for (int i = 0; i < BORNES_INVALIDES.length; i++) {
+            try {
+                programmeTest.listeBornee(BORNES_INVALIDES[i][DEBUT], 
+                                          BORNES_INVALIDES[i][FIN]);
+                echec();
+            } catch (InterpreteurException lancee) {
+                // Test OK
+            }
+        }
+    }
+    
+    /** 
+     * Test unitaire de {@link Programme#effacer(Etiquette, Etiquette)}
+     */
+    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"
+                    + "10 var tata = 0 + 0\n"
+                    + "13 var $titi = \"titi\"\n"
+                    + "31 entre tutu\n"
+                    + "40 var entier = 93\n"
+                    + "89 var $youpi = \"youpi lapin\"\n",
+            "",
+            "1 var $toto = \"toto\"\n"
+                    + "5 var $agreuagreu = \"agreu\"\n"
+                    + "10 var tata = 0 + 0\n"
+                    + "13 var $titi = \"titi\"\n"
+                    + "40 var entier = 93\n"
+                    + "89 var $youpi = \"youpi lapin\"\n",
+            "1 var $toto = \"toto\"\n"
+                    + "5 var $agreuagreu = \"agreu\"\n"
+                    + "89 var $youpi = \"youpi lapin\"\n",
+        };
+        
+        final Etiquette[][] BORNES_INVALIDES = {
+                { new Etiquette(8), new Etiquette(6) },
+                { new Etiquette(10000), new Etiquette(90) }
+        };
+        
+        System.out.println("\tExécution du test de effacer() : ");
+        
+        for (int i = 0; i < BORNES.length ; i++) {
+            ajoutLigne();
+            programmeTest.effacer(BORNES[i][DEBUT], BORNES[i][FIN]);
+            assertEquivalence(programmeTest.toString(), TEXTES_ATTENDUS[i]);
+        }
+        
+        for (int i = 0; i < BORNES_INVALIDES.length; i++) {
+            try {
+                programmeTest.effacer(BORNES_INVALIDES[i][DEBUT], 
+                                          BORNES_INVALIDES[i][FIN]);
+                echec();
+            } catch (InterpreteurException lancee) {
+                // Test OK
+            }
+        }
+        
+    }
+    
+    /** 
+     * Test unitaire de {@link Programme#stop()}
+     */
+    public void testStop() {
+        //TODO écrire les tests lorsque l'instruction stop sera définie
+        
+        System.out.println("\tExécution du test de stop() : ");
+        
+        echec();
+    }
+    
+    /** 
+     * Test unitaire de {@link Programme#lancer(Etiquette)}
+     */
+    public void testLancerEtiquette() {
+        final Etiquette[] ETIQUETTES_DEPART = {
+            new Etiquette(1),
+            new Etiquette(9),
+            new Etiquette(25),
+            new Etiquette(90)
+        };
+        
+        Expression.referencerContexte(contexteTest);
+        
+        ajoutLigne();
+        
+        System.out.println("\tExécution du test de lancer(Etiquette) "
+                           + "TEST INTERACTIF : ");
+
+        for (int i = 0; i < ETIQUETTES_DEPART.length; i++) {
+            System.out.println(programmeTest.listeBornee(ETIQUETTES_DEPART[i], 
+                                                         new Etiquette(9999)));
+
+            contexteTest.raz();
+            programmeTest.lancer(ETIQUETTES_DEPART[i]);
+            System.out.println(contexteTest.toString());
+        }
+    }
+    
+    /** 
+     * Test unitaire de {@link Programme#lancer()}
+     */
+    public void testLancer() {
+
+        Expression.referencerContexte(contexteTest);
+        contexteTest.raz();
+        
+        ajoutLigne();
+        
+        System.out.println("\tExécution du test de lancer() "
+                + "TEST INTERACTIF : ");
+        System.out.println(programmeTest.toString());
+        programmeTest.lancer();
+        System.out.println(contexteTest.toString());
+    }
+    
+    /** 
+     * Test unitaire de {@link Programme#appelProcedure(Etiquette)}
+     */
+    public void testAppelProcedure() {
+        //TODO écrire les tests
+        
+        System.out.println("\tExécution du test de appelProcedure(Etiquette) "
+                           + ": ");
+        
+        echec();
+    }
+    
+   /**
+    * Test unitaire de {@link Programme#retourProcedure()}
+    */
+   public void testRetourProcedure() {
+       
+       System.out.println("\tExécution du test de retourProcedure() : ");
+
+       // 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));
+
+       try {
+           programmeTest.retourProcedure();
+           programmeTest.retourProcedure();
+       } catch (ExecutionException lancee) {
+           echec();
+       }
+
+       try {
+           programmeTest.retourProcedure();
+           echec();
+       } catch (ExecutionException lancee) {
+           // Test OK
+       }
+   }
+   
+   /** 
+    * Test unitaire de {@link Programme#vaen(Etiquette)}
+    */
+   public void testVaen() {
+       //TODO écrire les tests
+       
+       System.out.println("\tExécution du test de vaen(Etiquette) "
+                          + ": ");
+       
+       echec();
+   }
+}