Mise en commun pour même base

src/interpreteurlir/Contexte.java

@@ -0,0 +1,147 @@
+/**
+ * Contexte.java                              7 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir;
+
+import java.util.ArrayList;
+
+import interpreteurlir.donnees.*;
+import interpreteurlir.donnees.litteraux.*;
+
+/**
+ * Le contexte contiens l'ensemble des variables définies au cours  d'un session
+ * d'interpréteur LIR.
+ * Il est le seul moyen d'accéder et modifier ces variables.
+ * Il sert donc d'interface entre le programme et les variables.
+ * L'accès à une variable se fait à partir d'un Identificateur.
+ * Les variables sont listée par ordre alphabétique des identificateurs.
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class Contexte {
+    
+    /** Valeur par défaut pour une Chaine */
+    public static final Chaine CHAINE_DEFAUT = new Chaine("\"\"");
+    
+    /** Valeur par défaut pour un Entier */
+    public static final Entier ENTIER_DEFAUT = new Entier(0);
+
+    /** Listes des variables définies dans ce contexte */
+    private ArrayList<Variable> variables;
+    
+    /**
+     * Initialise un contexte vide (aucune variable de définie)
+     */
+    public Contexte() {
+        super();
+        variables = new ArrayList<Variable>();
+    }
+    
+    /**
+     * Affecte valeur à la variable dans le contexte 
+     * ayant pour identificateur id. 
+     * Si cette variable n'existe pas alors elle est créée 
+     * et référence dans le contexte.
+     * @param id identificateur typé de la Variable
+     * @param valeur valeur typée à affecter à la variable
+     * @throws InterpreteurException si Variable lance l'exception.
+     *         {@link Variable#Variable(Identificateur, Litteral)}
+     */
+    public void ajouterVariable(Identificateur id, Litteral valeur) {
+        int indexVar = indexVariable(id);
+        
+        /* Ajout de variable absente à la fin */
+        if (variables.size() == indexVar) {
+            variables.add(indexVar, new Variable(id, valeur));
+            return;
+        }
+        // else
+        
+        
+        Variable varAIndex = variables.get(indexVar);
+        /* Variable déjà présente */
+        if (varAIndex.getIdentificateur().compareTo(id) == 0) {
+            varAIndex.setValeur(valeur);
+        } else {
+            /* Variable absente : ajout à son index trié */
+            variables.add(indexVar, new Variable(id, valeur));
+        }
+    }   
+    
+    /**
+     * Lecture de la valeur d'une variable du contexte.
+     * @param id identificateur de la variable dont on veut la valeur
+     * @return Si la variable est définie alors sa valeur est retournée.
+     *         Sinon la valeur par défaut (CHAINE_DEFAUT ou ENTIER_DEFAUT) 
+     *         selon type de id est retournée.
+     */
+    public Litteral lireValeurVariable(Identificateur id) {
+        Litteral valeur;
+        int indexVar = indexVariable(id);
+        if (variables.size() > indexVar
+                && variables.get(indexVar).getIdentificateur().compareTo(id) 
+                   == 0) {
+            /* La variables est présente */
+            valeur = variables.get(indexVar).getValeur();
+        } else if (id instanceof IdentificateurChaine) {
+            valeur = CHAINE_DEFAUT;
+        } else {
+            valeur = ENTIER_DEFAUT;
+        }
+
+        return valeur;
+        
+    }
+    
+    /**
+     * Recherche de l'index théorique ou réel de la variable ayant id comme
+     * identificateur.
+     * @param id identificateur dont on cherche l'index de la variable
+     * @return index de la Variable ayant id comme identificateur. 
+     *         Si la variable n'existe pas alors c'est l'index de la place
+     *         théorique de variable pour qu'elle soit triée qui est renvoyé.
+     */
+    private int indexVariable(Identificateur id) {
+        int index;
+        int taille = variables.size();
+        for (index = 0; index < taille; index++) {
+            if (variables.get(index).getIdentificateur().compareTo(id) >= 0) {
+                return index;
+            }
+        }
+        return index;
+    }
+
+    /* non javadoc
+     * @see java.lang.Object#toString()
+     */
+    @Override
+    public String toString() {
+        final String MSG_VIDE = "aucune variable n'est définie\n";
+        int taille = variables.size();
+        
+        if (taille == 0) {
+            return MSG_VIDE;
+        }
+        // else
+        
+        StringBuilder resultat = new StringBuilder("");
+        for (int index = 0 ; index < taille ; index++) {
+            resultat.append(variables.get(index) + "\n");
+        }
+        return resultat.toString();
+    }
+    
+    /**
+     * Remise à zéro du contexte.
+     * Efface toutes les variables mémorisée par le contexte.
+     */
+    public void raz() {
+        variables.clear();
+    }
+    
+}

src/interpreteurlir/InterpreteurException.java

@@ -0,0 +1,25 @@
+/**
+ * InterpreteurException.java                              7 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir;
+
+/**
+ * Exception levée lors d'une erreur dans l'interpreteur LIR.
+ * (Erreur de syntaxe, erreur de types)
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class InterpreteurException extends RuntimeException {
+    
+    /** 
+     * Une exception de syntaxe expliquée par un message
+     * @param message explication succincte de cette exception
+     */
+    public InterpreteurException(String message) {
+        super(message);
+    }
+}

src/interpreteurlir/donnees/Identificateur.java

@@ -0,0 +1,128 @@
+/*
+ * Identificateur.java , 08/05/2021
+ * IUT Rodez 2020-2021, info1
+ * pas de copyright, aucun droits
+ */
+
+package interpreteurlir.donnees;
+
+/**
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+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 */
+    private String nom;
+        
+    /**
+     * Instantiation de l'identificateur
+     * @param identificateur
+     */
+        public Identificateur(String identificateur) {
+                super();
+                if(!isIdentificateur(identificateur)) {
+                    throw new IllegalArgumentException(identificateur
+                                                       + " n'est pas un identificateur");
+                }
+                
+                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 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';
+        }
+        
+        /**
+     * @return la valeur de nom
+     */
+    public String getNom() {
+        return nom;
+    }
+
+    /* non javadoc - @see java.lang.Object#toString() */
+    @Override
+    public String toString() {
+        return nom;
+    }
+
+    /* non javadoc - @see java.lang.String#Comparable() */
+    @Override
+    public int compareTo(Identificateur aComparer) {
+        return nom.compareTo(aComparer.nom);
+    }
+    
+    
+}

src/interpreteurlir/donnees/IdentificateurChaine.java

@@ -0,0 +1,46 @@
+/*
+ * IdentificateurChaine.java, 08/05/2021
+ * IUT Rodez 2020-2021, info1
+ * pas de copyright, aucun droits
+ */
+
+package interpreteurlir.donnees;
+
+/**
+ * Identificateur de chaîne
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class IdentificateurChaine extends Identificateur {
+
+    /**
+         * Instantiation d'identificateur de chaîne
+         * @param identificateur a instancier
+         * @throws IllegalAccessException si l'identificateur est invalide
+         */
+        public IdentificateurChaine(String identificateur) {
+                super(identificateur);
+                
+                if(!isIdentificateurChaine(identificateur)) {
+                        throw new IllegalArgumentException(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));
+        }
+}

src/interpreteurlir/donnees/IdentificateurEntier.java

@@ -0,0 +1,51 @@
+/*
+ * IdentificateurEntier.java , 08/05/2021
+ * IUT Rodez 2020-2021, info1
+ * pas de copyright, aucun droits
+ */
+
+package interpreteurlir.donnees;
+
+/**
+ * Identificateur d'entier
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class IdentificateurEntier extends Identificateur {
+
+        /**
+         * Instantiation d'identificateur d'entier
+         * @param identificateur a instancier
+         * @throws IllegalAccessException si l'identificateur est invalide
+         */
+        public IdentificateurEntier(String identificateur) {
+                super(identificateur);
+                
+                if(!isIdentificateurEntier(identificateur)) {
+                        throw new IllegalArgumentException(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));
+        }
+}

src/interpreteurlir/donnees/Variable.java

@@ -0,0 +1,80 @@
+/**
+ * Variable.java                              8 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.donnees;
+
+import interpreteurlir.donnees.litteraux.Litteral;
+
+/** TODO commenter la responsabilité de cette classe
+ * BOUCHON
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class Variable implements Comparable<Variable> {
+
+    /** BOUCHON identificateurs car Identificateurs non finis */
+    private Identificateur identificateur;
+    
+    /** BOUCHON valeur*/
+    private Litteral valeur;
+    
+    /** TODO commenter l'état initial
+     * @param id
+     * @param valeur
+     */
+    public Variable(Identificateur id, Litteral valeur) {
+        super();
+        this.identificateur = id;
+        this.valeur = valeur;
+    }
+    
+    /**
+     * @return valeur de valeur
+     */
+    public Litteral getValeur() {
+        return valeur;
+    }
+
+    /**
+     * @param valeur nouvelle valeur de valeur
+     */
+    public void setValeur(Litteral valeur) {
+        this.valeur = valeur;
+    }
+    
+    /* non javadoc
+     * @see java.lang.Comparable#compareTo(java.lang.Object)
+     */
+    @Override
+    public int compareTo(Variable o) {
+        // bouchon
+        return identificateur.compareTo(o.identificateur);
+    }
+
+    /**
+     * @return valeur de id
+     */
+    public Identificateur getIdentificateur() {
+        return identificateur;
+    }
+
+    /* non javadoc
+     * @see java.lang.Object#toString()
+     */
+    @Override
+    public String toString() {
+        return identificateur + " = " + valeur;
+    }
+    
+    
+    
+    
+    
+    
+    
+
+}

src/interpreteurlir/donnees/litteraux/Chaine.java

@@ -0,0 +1,83 @@
+/**
+ * Chaine.java                                    7 mai 2021
+ * IUT info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.donnees.litteraux;
+
+import interpreteurlir.InterpreteurException;
+
+/**  
+ * Constante littérale de type chaîne de caractères.
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class Chaine extends Litteral {
+        
+        /** Longueur maximale d'une chaîne */
+        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";
+        
+        /** Erreur constante littéral chaîne invalide */
+        private static final String ERREUR_INVALIDE = 
+                "syntaxe incorrecte pour une constante de type chaîne : ";
+        
+        /**
+         * initialise cette chaîne avec  une valeur par défaut.
+         */
+        public Chaine() {
+                valeur = "";
+        }
+
+        /** 
+         * Initialise une chaîne avec la séquence de caractères passée en argument.
+         * @param uneValeur
+         */
+        public Chaine(String uneValeur) {
+                
+                if (!uneValeur.startsWith("\"") || !uneValeur.endsWith("\"")) {
+                    throw new InterpreteurException(ERREUR_INVALIDE 
+                                                    + uneValeur);
+                }
+                
+                uneValeur = uneValeur.substring(1, uneValeur.length() - 1);
+                
+                if (uneValeur.length() > LG_MAX_CHAINE) 
+                    throw new InterpreteurException(ERREUR_LG_MAX);
+                    
+                valeur = uneValeur;
+        }
+        
+        /** 
+         * Concatène deux chaînes ensemble. Opération non commutative: 
+         * a + b != b + a
+         * @param a une Chaîne
+         * @param b une autre Chaîne
+         * @return une nouvelle Chaîne.
+         */
+        public static Chaine concatener(Chaine a, Chaine b) {
+                
+                return null;
+        }
+        
+        /* non javadoc
+         * @see interpreteurlir.donnees.litteraux.Litteral#compareTo(interpreteurlir.donnees.litteraux.Litteral)
+         */
+        @Override
+        public int compareTo(Litteral autre) {
+                // TODO Auto-generated method stub
+                return this.valeur.toString().compareTo(autre.valeur.toString());
+        }
+
+        /* non javadoc
+         * @see java.lang.Object#toString()
+         */
+        @Override
+        public String toString() {
+                return '\"' + valeur.toString() + '\"';
+        }
+}

src/interpreteurlir/donnees/litteraux/Entier.java

@@ -0,0 +1,34 @@
+/**
+ * Entier.java                              8 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.donnees.litteraux;
+
+/**
+ * BOUCHON
+ * @author 
+ *
+ */
+public class Entier extends Litteral {
+
+    
+    /** TODO commenter l'état initial
+     * @param i
+     */
+    public Entier(int i) {
+        super(Integer.valueOf(i));
+        // TODO Auto-generated constructor stub
+        valeur = i;
+    }
+
+    /* non javadoc
+     * @see java.lang.Object#toString()
+     */
+    @Override
+    public String toString() {
+        return valeur.toString();
+    }
+    
+    
+
+}

src/interpreteurlir/donnees/litteraux/Litteral.java

@@ -0,0 +1,63 @@
+/**
+ * Litteral.java                                    7 mai 2021
+ * IUT info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.donnees.litteraux;
+
+/**
+ * Valeur littérale utilisée dans une expression.
+ * Chaque littérale est reconnue par sont type.
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class Litteral implements Comparable<Litteral> {  
+        
+        /** valeur de ce littéral */
+        protected Object valeur;
+        
+        /** 
+         * Initialise ce littéral par défaut. 
+         */
+        protected Litteral() {
+                super();
+        }
+
+        /** 
+         * Initialise cette valeur avec un objet argument.
+         * @param valeur
+         */
+        public Litteral(Object valeur) {  // TODO public >>> protected
+                super();
+                this.valeur = valeur;
+        }
+
+        /**
+         * @return la valeur de valeur
+         */
+        public Object getValeur() {
+                return valeur;
+        }
+
+        /* non javadoc
+         * @see java.lang.Object#toString()
+         */
+        @Override
+        public String toString() {
+                return valeur.toString();
+        }
+
+        /* non javadoc
+         * @see java.lang.Comparable#compareTo(java.lang.Object)
+         */
+        @Override
+        public int compareTo(Litteral autre) {
+                
+                if (autre.valeur.getClass() == this.valeur.getClass())
+                    return 0;
+                
+                return this.valeur.hashCode() - autre.valeur.hashCode();
+        }
+}

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

@@ -0,0 +1,123 @@
+/**
+ * TestChaine.java                                    8 mai 2021
+ * IUT info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.donnees.litteraux.tests;
+
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.donnees.litteraux.Chaine;
+
+/**  
+ * Tests unitaires de Chaine
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class TestChaine {
+	
+	
+	/** test de Chaine(String) */
+	public static void testChaine() {
+		
+		final String[] VALIDE = { 
+			"\"arztyehjklmpoijhghnbghjklmpoiuytrf" + 
+			"ghjnklmpoiuytrezaqsdfghnjklmpjbfrtyu\"", 
+			"\"\"","\"coucou \"",
+			"\"" + 42 + "\""
+		};  
+		
+	    final String INVALIDE =
+			"arztyehjklmpoijhghnbghjklmpoiuytrf" + 
+			"yeryghjnklmpoiuytrezaqsdfghnjklmpjbfrtyu";
+
+	    System.out.println("test de Chaine(String)");
+	    
+	    for (String aTester : VALIDE)
+	    	new Chaine(aTester);
+	    
+	    try {
+	    	new Chaine(INVALIDE);
+	    	throw new RuntimeException("Instanciation interdite");
+	    } catch (InterpreteurException lancee) {
+	    	System.out.println("Revoi d'exception OK\nfin du test");
+	    }
+	}
+	
+	/** test  de compareTo */
+	public static void testCompareTo() {
+		final Chaine[][] EGALITES = { 
+			{new Chaine("\"coucou\""), new Chaine("\"coucou\"")}, 
+			{new Chaine("\" \""), new Chaine("\" \"")},
+			{new Chaine("\"\""), new Chaine()} 
+		};
+		
+		final Chaine[][] DIFFERENCES = { 
+			{new Chaine("\"coucou\""), new Chaine("\"camomille\"")},
+			{new Chaine("\"tarentule\""), new Chaine("\"coucou\"")}, 
+			{new Chaine("\"coucou\""), new Chaine("\" \"")}, 
+			{new Chaine("\"coucou\""), new Chaine()},
+			{new Chaine("\" \""), new Chaine()} 
+		};
+		
+		System.out.println("test de compareTo(Chaine)\nAvec égalités");
+		
+		for (Chaine[] couple : EGALITES) {
+			
+			try {
+		    	assert couple[0].compareTo(couple[1]) == 0;
+		    } catch (AssertionError lancee) {
+				System.err.println("Echec du test");
+		    }	
+			
+		}
+		
+		System.out.println("Avec des inégalités");
+		for (Chaine[] couple : DIFFERENCES) {
+			try {
+		    	assert couple[0].compareTo(couple[1]) > 0;
+		    } catch (AssertionError lancee) {
+				System.err.println("Echec du test");
+		    }
+		}
+		System.out.println("fin du test");
+	
+	}
+	
+	/** test de toString */
+	public static void testToString() {
+		final Chaine[] A_AFFICHER = {
+			new Chaine(), new Chaine("\" \""), 
+			new Chaine("\"coucou\""),
+			new Chaine("\" coucou \""), 
+			new Chaine("\"coucou monsieur\"")
+		};
+		
+		final String[] AFFICHAGE_GUILLEMETS = {
+				"\"\"", "\" \"", "\"coucou\"", "\" coucou \"",
+				"\"coucou monsieur\""
+		};
+		
+		System.out.println("test de toString");
+		for (int i = 0 ; i < A_AFFICHER.length ; i++) {
+			
+			try {
+				assert A_AFFICHER[i].toString().equals(AFFICHAGE_GUILLEMETS[i]);
+			} catch (AssertionError lancee) {
+				System.err.println("Echec du test a l'indice " + i);
+			}
+		}
+		System.out.println("==>test terminé\n");		
+	}
+	
+	/** 
+	 * Lancement des tests
+	 * @param args non utilisés
+	 */
+	public static void main(String[] args) {
+		testChaine();
+		testCompareTo();
+		testToString();
+	}
+}

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

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

src/interpreteurlir/donnees/tests/TestIdentificateur.java

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

src/interpreteurlir/donnees/tests/TestIdentificateurChaine.java

@@ -0,0 +1,92 @@
+/*
+ * TestIdentificateurChaine.java, 08/05/2021
+ * IUT Rodez 2020-2021, info1
+ * pas de copyright, aucun droits
+ */
+
+package interpreteurlir.donnees.tests;
+
+import static info1.outils.glg.Assertions.*;
+
+import interpreteurlir.donnees.IdentificateurChaine;
+
+/**
+ * Tests unitaires de la classe donnees.IdentificateurEntier
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class TestIdentificateurChaine {
+	/** Jeu d'identificateurs de chaîne correctement instanciés */
+    private static IdentificateurChaine[] FIXTURE = {
+            new IdentificateurChaine("$a"),
+            new IdentificateurChaine("$A"),
+            new IdentificateurChaine("$alpha"),
+            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
+    		}
+    	}
+    }
+    
+    /**
+     * 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());
+    	}
+    }
+}

src/interpreteurlir/donnees/tests/TestIdentificateurEntier.java

@@ -0,0 +1,83 @@
+/*
+ * TestIdentificateurEntier.java , 08/05/2021
+ * IUT Rodez 2020-2021, info1
+ * pas de copyright, aucun droits
+ */
+
+package interpreteurlir.donnees.tests;
+
+import static info1.outils.glg.Assertions.*;
+
+import interpreteurlir.donnees.IdentificateurEntier;
+
+/**
+ * Tests unitaires de la classe donnees.IdentificateurEntier
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class TestIdentificateurEntier {
+	
+	/** 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")
+	};
+    
+    /**
+     * 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
+    		}
+    	}
+    }
+    
+    /**
+     * 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());
+    	}
+    }
+}

src/interpreteurlir/expressions/Expression.java

@@ -0,0 +1,78 @@
+/**
+ * Expression.java                              7 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.expressions;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.donnees.litteraux.Litteral;
+
+/**
+ * Une expression contient tous les liens et données nécessaires à son calcul.
+ * Une expression peut être calculée pour obtenir une valeur.
+ * Elle peut affecter une valeur à une variable dans le contexte.
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class Expression {
+
+    /** Contexte global pour accéder aux données. */
+    private static Contexte contexteGlobal;
+    
+    // TODO stocker opérandes (identificateur ou Litteral)
+    
+    /**
+     * Initialise une expression par défaut avec les liens nécessaires à
+     * son calcul.
+     */
+    protected Expression() {
+        super();
+    }
+    
+    /**
+     * Calculer la valeur de cette expression à ce moment précis.
+     * Peut accéder au contexte.
+     * @return un Litteral de valeur du résultat de l'expression
+     */
+    public Litteral calculer() {
+        return null;
+        
+    }   
+    
+    /* non javadoc
+     * @see java.lang.Object#toString()
+     */
+    @Override
+    public String toString() {
+        return "Expression#toString() BOUCHON";
+    }
+
+    /**
+     * Référence le contexte pour accéder aux variables lors du calcul.
+     * Le référencement vaut pour toutes les expressions 
+     * et est possible une unique fois.
+     * @param aReferencer référence du contexte global
+     * @return <ul><li>true si le contexte a pu être référencé</li>
+     *             <li>false si aReferencer est null</li>
+     *             <li>false si un contexte est déjà référencer</li>
+     *         </ul>
+     */
+    public static boolean referencerContexte(Contexte aReferencer) {
+        return false;
+    }
+    
+    /**
+     * Détermine et créé une expression du bon type selon texteExpression.
+     * @param texteExpression texte suivant la syntaxe d'une expression
+     * @return l'expression du bon type correspondant à texteExpression
+     * @throws InterpreteurException si texteExpression n'est pas valide
+     *                               ou amène à une incohérence de type
+     */
+    public static Expression determinerType(String texteExpression) {
+        return null;
+    }
+}

src/interpreteurlir/expressions/ExpressionChaine.java

@@ -0,0 +1,50 @@
+/**
+ * ExpressionChaine.java                              7 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.expressions;
+
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.donnees.litteraux.Chaine;
+
+/**
+ * Expression de type Chaine qui peut être calculer.
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class ExpressionChaine extends Expression {
+
+    /**
+     * Initalise une expression de type Chaine avec les liens nécessaires à son
+     * calcule.
+     * @param texteExpression texte suivant la syntaxe d'une expression
+     * @throws InterpreteurException si texteExpression n'est pas valide
+     *                               ou amène à une incohérence de type
+     */
+    public ExpressionChaine(String texteExpression) {
+        super();
+        // TODO
+    }
+
+    /* non javadoc
+     * @see interpreteurlir.expressions.Expression#calculer()
+     */
+    @Override
+    public Chaine calculer() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    /* non javadoc
+     * @see interpreteurlir.expressions.Expression#toString()
+     */
+    @Override
+    public String toString() {
+        // TODO Auto-generated method stub
+        return "ExpressionChaine#toString() BOUCHON";
+    }
+
+}

src/interpreteurlir/expressions/ExpressionEntier.java

@@ -0,0 +1,50 @@
+/**
+ * ExpressionEntier.java                              7 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.expressions;
+
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.donnees.litteraux.Entier;
+
+/**
+ * Expression de type Entier qui peut être calculer.
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class ExpressionEntier extends Expression {
+
+    /**
+     * Initalise une expression de type Entier avec les liens nécessaires à son
+     * calcule.
+     * @param texteExpression texte suivant la syntaxe d'une expression
+     * @throws InterpreteurException si texteExpression n'est pas valide
+     *                               ou amène à une incohérence de type
+     */
+    public ExpressionEntier(String texteExpression) {
+        super();
+        // TODO
+    }
+
+    /* non javadoc
+     * @see interpreteurlir.expressions.Expression#calculer()
+     */
+    @Override
+    public Entier calculer() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    /* non javadoc
+     * @see interpreteurlir.expressions.Expression#toString()
+     */
+    @Override
+    public String toString() {
+        // TODO Auto-generated method stub
+        return "ExpressionEntier#toString() BOUCHON";
+    }
+
+}

src/interpreteurlir/expressions/tests/TestExpression.java

@@ -0,0 +1,19 @@
+/**
+ * TestExpression.java                              7 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.expressions.tests;
+
+import interpreteurlir.expressions.Expression;
+
+/**
+ * Tests unitaires de {@link Expression}
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class TestExpression {
+
+}

src/interpreteurlir/expressions/tests/TestExpressionChaine.java

@@ -0,0 +1,19 @@
+/**
+ * TestExpressionChaine.java                              7 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.expressions.tests;
+
+import interpreteurlir.expressions.Expression;
+
+/**
+ * Tests unitaires de {@link Expression}
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class TestExpressionChaine {
+
+}

src/interpreteurlir/expressions/tests/TestExpressionEntier.java

@@ -0,0 +1,19 @@
+/**
+ * TestExpressionEntier.java                              7 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.expressions.tests;
+
+import interpreteurlir.expressions.Expression;
+
+/**
+ * Tests unitaires de {@link Expression}
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class TestExpressionEntier {
+
+}

src/interpreteurlir/motscles/Commande.java

@@ -0,0 +1,58 @@
+/**
+ * Commande.java                                 7 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.motscles;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.InterpreteurException;
+
+/**
+ * Une commande (générale) n'a aucun comportement. 
+ * Voir les sous-classes pour les comportements.
+ * Une commande contient tous les liens nécessaires à son exécution.
+ * Une commande peut être exécutée.
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class Commande {
+    
+    /** référence du contexte possiblement manié directement par la commande */
+    protected Contexte contexte;
+
+    /**
+     * Initialise une commande avec les liens dont elle a besoin pour 
+     * s'exécuter à partir des arguments. 
+     * Cependant la commande ne s'exécute pas à la construction.
+     * La commande a accès au contexte passé en argument.
+     * @param arguments chaîne de texte représentant les arguments
+     * @param contexte référence du contexte global
+     * @throws InterpreteurException est propagée si Commande la reçoit
+     * @throws NullPointerException si contexte ou arguments est null
+     */
+    public Commande(String arguments, Contexte contexte) {
+        super();
+        if (arguments == null || contexte == null) {
+            throw new NullPointerException();
+        }
+        
+        // arguments non utilisés dans Commande générale
+        this.contexte = contexte;
+    }
+    
+    /**
+     * Commande d'exécution de la commande.
+     * @return true si la commande affiche un feedback directement sur la sortie
+     *         standard, sinon false
+     */
+    public boolean executer() {
+        // pas de comportement pour une Commande générale
+        return false; // pas de feedback
+    }
+        
+    
+
+}

src/interpreteurlir/motscles/CommandeDebut.java

@@ -0,0 +1,56 @@
+/**
+ * CommandeDebut.java                              7 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.motscles;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.InterpreteurException;
+
+/**
+ * La commande debut n'a aucun arguments.
+ * Lors de son exécution :
+ * <ul><li>tous les identificateurs du contexte sont supprimés</li>
+ *     <li>toutes les lignes de programmes mémorisée sont effacées</li>
+ * </ul>
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class CommandeDebut extends Commande {
+
+    // TODO adapter la classe aux programmes
+    
+    /**
+     * Initialise une commande debut qui est sans arguments 
+     * et qui a besoin du contexte.
+     * @param arguments arguments de debut soit chaîne blanche ou vide
+     * @param contexte référence du contexte global
+     * @throws InterpreteurException si arguments n'est pas une chaîne blanche
+     * @throws NullPointerException si contexte ou arguments est null
+     */
+    public CommandeDebut(String arguments, Contexte contexte) {
+        super(arguments, contexte);
+        
+        final String ERREUR_ARGUMENTS = "la commande debut n'a pas d'arguments";
+        
+        if (!arguments.isBlank()) {
+            throw new InterpreteurException(ERREUR_ARGUMENTS);
+        }
+    }
+    
+    
+    /**
+     * Commande d'exécution de la commande.
+     * Efface le contexte.
+     * @return false car aucun feedback afficher directement
+     */
+    @Override
+    public boolean executer() {
+        contexte.raz();
+        return false;
+    }
+
+}

src/interpreteurlir/motscles/CommandeDefs.java

@@ -0,0 +1,52 @@
+/**
+ * CommandeDefs.java                              7 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.motscles;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.InterpreteurException;
+
+/**
+ * La commande defs n'a aucun argument.
+ * Lors de son exécution, elle affiche le contenu du contexte 
+ * (liste des identificateurs avec leurs valeurs)
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class CommandeDefs extends Commande {
+
+    /**
+     * Initialise une commande defs qui est sans arguments et qui a
+     * besoin du contexte
+     * @param arguments arguments de defs soit chaîne blanche ou vide
+     * @param contexte référence du contexte global
+     * @throws InterpreteurException si arguments n'est pas une chaîne blanche
+     * @throws NullPointerException si contexte ou arguments est null
+     */
+    public CommandeDefs(String arguments, Contexte contexte) {
+        super(arguments, contexte);
+        
+        final String ERREUR_ARGUMENTS = "la commande defs n'a pas d'arguments";
+        
+        if (!arguments.isBlank()) {
+            throw new InterpreteurException(ERREUR_ARGUMENTS);
+        }
+    }
+
+    /**
+     * Commande d'exécution de la commande.
+     * Affiche le contexte (liste des identificateurs avec leurs valeurs).
+     * @return true car l'affichage est un feedback directe de la commande
+     */
+    @Override
+    public boolean executer() {
+        System.out.print(contexte.toString());
+        return true;
+    }
+    
+
+}

src/interpreteurlir/motscles/CommandeFin.java

@@ -0,0 +1,54 @@
+/**
+ * CommandeFin.java                              7 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.motscles;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.InterpreteurException;
+
+/**
+ * La commande fin n'a aucun argument.
+ * Lors de son exécution, elle permet de quitter l'interpreteur en affichant un
+ * message d'aurevoir.
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class CommandeFin extends Commande {
+
+    /**
+     * Initialise une commande fin qui est sans arguments.
+     * @param arguments arguments de fin soit chaîne blanche ou vide
+     * @param contexte référence du contexte global
+     * @throws InterpreteurException si arguments n'est pas une chaîne blanche
+     * @throws NullPointerException si contexte ou arguments est null
+     */
+    public CommandeFin(String arguments, Contexte contexte) {
+        super(arguments, contexte);
+        
+        final String ERREUR_ARGUMENTS = "la commande fin n'a pas d'arguments";
+        
+        if (!arguments.isBlank()) {
+            throw new InterpreteurException(ERREUR_ARGUMENTS);
+        }
+    }
+
+    
+    /**
+     * Commande d'exécution de la commande.
+     * Quitte l'interpreteur en affichant un message d'aurevoir.
+     * @return true si la commande affiche un feedback directement sur la sortie
+     *         standard, sinon false
+     */
+    @Override
+    public boolean executer() {
+        final String MESSAGE_AUREVOIR = "Au revoir, à bientôt !";
+        
+        System.out.println(MESSAGE_AUREVOIR);
+        System.exit(0);
+        return true;
+    }
+}

src/interpreteurlir/motscles/tests/EssaiCommande.java

@@ -0,0 +1,70 @@
+/**
+ * EssaiCommande.java                              7 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.motscles.tests;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.motscles.*;
+
+/**
+ * Essais des commandes (création + éxécution)
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class EssaiCommande {
+
+    /**
+     * Essais de commandes avec arguments invalides puis valides
+     * @param args non utilisé
+     */
+    public static void main(String[] args) {
+        Contexte contexte = new Contexte();
+        
+        /* Erreur dans commande */
+        System.out.println("? debut args");
+        try {
+            new CommandeDebut("args", contexte);
+        } catch (InterpreteurException lancee) {
+            feedback(lancee);
+        }
+        System.out.println("? defs args");
+        try {
+            new CommandeDefs("args", contexte);
+        } catch (InterpreteurException lancee) {
+            feedback(lancee);
+        }
+        System.out.println("? fin args");
+        try {
+            new CommandeFin("args", contexte);
+        } catch (InterpreteurException lancee) {
+            feedback(lancee);
+        }
+        
+        /* Commande valide et exécution */
+        System.out.println("? debut");
+        feedback(new CommandeDebut("", contexte).executer());
+        System.out.println("? defs");
+        feedback(new CommandeDefs( "", contexte).executer());
+        System.out.println("? fin");
+        feedback(new CommandeFin(  "", contexte).executer());
+        
+        System.err.println("Erreur, la commande fin n'a pas quitter");
+
+    }
+    
+    private static void feedback(boolean nonBesoinFeedback) {
+        if (!nonBesoinFeedback) {
+            System.out.println("ok");
+        }
+    }
+    
+    private static void feedback(InterpreteurException lancee) {
+        System.out.println("nok : " + lancee.getMessage());
+    }
+
+}

src/interpreteurlir/motscles/tests/TestCommande.java

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

src/interpreteurlir/motscles/tests/TestCommandeDebut.java

@@ -0,0 +1,68 @@
+/**
+ * TestCommandeDebut.java                              7 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.motscles.tests;
+
+import static info1.outils.glg.Assertions.*;
+
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.Contexte;
+import interpreteurlir.motscles.CommandeDebut;
+
+/**
+ * Tests unitaires de {@link interpreteurlir.motscles.CommandeDebut}
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class TestCommandeDebut {
+ 
+    /** Jeux d'essais de CommandeDebut valides pour les tests */
+    private CommandeDebut[] fixture = { 
+            new CommandeDebut("", new Contexte()),
+            new CommandeDebut("    ", new Contexte()),
+            new CommandeDebut("\t", new Contexte()),
+    };
+    
+    /**
+     * Tests unitaires de {@link CommandeDebut#CommandeDebut(String, Contexte)}
+     */
+    public void testCommandeDebutStringContexte() {
+        System.out.println("\tExécution du test de CommandeDebut"
+                           + "#CommandeDebut(String, Contexte)");
+        
+        /* Tests Commande invalide */
+        String[] arguments = { "$chaine", " a   ", "fin" };
+        Contexte contexte = new Contexte();
+        for (int numTest = 0 ; numTest < arguments.length ; numTest++) {
+            try {
+                new CommandeDebut(arguments[numTest], contexte);
+                echec();
+            } catch (InterpreteurException lancee) { 
+            }
+        }
+        
+        try {
+            new CommandeDebut("", new Contexte());
+            new CommandeDebut("    ", new Contexte());
+            new CommandeDebut("\t", new Contexte());
+        } catch (InterpreteurException e) {
+            echec();
+        }
+    }
+    
+    
+    /**
+     * Tests unitaires de {@link CommandeDebut#executer()}
+     */
+    public void testExecuter() {
+        System.out.println("\tExécution du test de CommandeDebut#executer()");
+        for (CommandeDebut cmd : fixture) {
+            assertFalse(cmd.executer());
+        }
+        
+    }
+}

src/interpreteurlir/motscles/tests/TestCommandeDefs.java

@@ -0,0 +1,69 @@
+/**
+ * TestCommandeDefs.java                              7 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.motscles.tests;
+
+import static info1.outils.glg.Assertions.*;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.motscles.CommandeDefs;
+
+/**
+ * Tests unitaires de {@link interpreteurlir.motscles.CommandeDefs}
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class TestCommandeDefs {
+ 
+    /** Jeux d'essais de CommandeDefs valides pour les tests */
+    private CommandeDefs[] fixture = { 
+            new CommandeDefs("", new Contexte()),
+            new CommandeDefs("    ", new Contexte()),
+            new CommandeDefs("\t", new Contexte()),
+    };
+    
+    /**
+     * Tests unitaires de {@link CommandeDefs#CommandeDefs(String, Contexte)}
+     */
+    public void testCommandeDefsStringContexte() {
+        System.out.println("\tExécution du test de CommandeDefs"
+                           + "#CommandeDefs(String, Contexte)");
+        
+        /* Tests Commande invalide */
+        String[] arguments = { "$chaine", " a   ", "fin" };
+        Contexte contexte = new Contexte();
+        for (int numTest = 0 ; numTest < arguments.length ; numTest++) {
+            try {
+                new CommandeDefs(arguments[numTest], contexte);
+                echec();
+            } catch (InterpreteurException lancee) { 
+            }
+        }
+        
+        try {
+            new CommandeDefs("", new Contexte());
+            new CommandeDefs("    ", new Contexte());
+            new CommandeDefs("\t", new Contexte());
+        } catch (InterpreteurException e) {
+            echec();
+        }
+    }
+    
+    
+    /**
+     * Tests unitaires de {@link CommandeDefs#executer()}
+     */
+    public void testExecuter() {
+        System.out.println("\tExécution du test de CommandeDefs#executer()");
+        for (CommandeDefs cmd : fixture) {
+            System.out.println("Affichage du contexte :");
+            assertTrue(cmd.executer());
+        }
+        
+    }
+}

src/interpreteurlir/motscles/tests/TestCommandeFin.java

@@ -0,0 +1,67 @@
+/**
+ * TestCommandeFin.java                              7 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.motscles.tests;
+
+import static info1.outils.glg.Assertions.*;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.InterpreteurException;
+import interpreteurlir.motscles.CommandeFin;
+
+/**
+ * Tests unitaires de {@link interpreteurlir.motscles.CommandeFin}
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class TestCommandeFin {
+ 
+    /** Jeux d'essais de Commande valides pour les tests */
+    private CommandeFin[] fixture = { 
+            new CommandeFin("", new Contexte()),
+    };
+    
+    /**
+     * Tests unitaires de {@link CommandeFin#CommandeFin(String, Contexte)}
+     */
+    public void testCommandeFinStringContexte() {
+        System.out.println("\tExécution du test de CommandeFin"
+                           + "#CommandeFin(String, Contexte)");
+        
+        /* Tests Commande invalide */
+        String[] arguments = { "$chaine", " a   ", "fin" };
+        Contexte contexte = new Contexte();
+        for (int numTest = 0 ; numTest < arguments.length ; numTest++) {
+            try {
+                new CommandeFin(arguments[numTest], contexte);
+                echec();
+            } catch (InterpreteurException lancee) { 
+            }
+        }
+        
+        try {
+            new CommandeFin("", new Contexte());
+            new CommandeFin("    ", new Contexte());
+            new CommandeFin("\t", new Contexte());
+        } catch (InterpreteurException e) {
+            echec();
+        }
+    }
+    
+    
+    /**
+     * Tests unitaires de {@link CommandeFin#executer()}
+     */
+    public void testExecuter() {
+        System.out.println("\tExécution du test de CommandeFin#executer()");
+        System.out.println("\tLe programme doit s'éteindre en affichant un "
+                           + "message d'aurevoir :");
+        System.out.println("Test exécuter désactiver");
+//        fixture[0].executer();
+        echec();
+    }
+}

src/interpreteurlir/tests/EssaiInterpreteurException.java

@@ -0,0 +1,40 @@
+/**
+ * EssaiInterpreteurException.java                              7 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.tests;
+
+import interpreteurlir.InterpreteurException;
+
+/**
+ * Essai des {@link InterpreteurException}
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class EssaiInterpreteurException {
+
+    /**
+     * Lancement des essais.
+     * @param args non utilisé
+     */
+    public static void main(String[] args) {
+        String[] messages = { 
+            null, 
+            "", 
+            "la commande fin n'accepte pas d'arguments"
+        };
+        
+        for (String msg : messages) {
+            System.out.print("Message de l'exception : ");
+            try {
+                throw new InterpreteurException(msg);
+            } catch (InterpreteurException lancee) {
+                System.out.println(lancee.getMessage());
+            }
+        }
+    }
+
+}

src/interpreteurlir/tests/TestContexte.java

@@ -0,0 +1,170 @@
+/**
+ * TestContexte.java                              8 mai 2021
+ * IUT Rodez info1 2020-2021, pas de copyright, aucun droit
+ */
+package interpreteurlir.tests;
+
+import static info1.outils.glg.Assertions.*;
+
+import interpreteurlir.Contexte;
+import interpreteurlir.donnees.*;
+import interpreteurlir.donnees.litteraux.*;
+
+/**
+ * Tests unitaires de {@link Contexte}
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heïa Dexter
+ * @author Lucas Vabre
+ */
+public class TestContexte {
+
+    /** Jeux de tests de Contexte */
+    private Contexte[] fixture = { 
+            new Contexte(), new Contexte(), new Contexte(),
+    };
+    
+    /**
+     * Tests unitaires de {@link Contexte#Contexte()}
+     */
+    public void testContexte() {
+        System.out.println("\tExécution du test de Contexte#Contexte()");
+        try {
+            new Contexte();  
+        } catch (Exception e) {
+            echec();
+        }
+    }
+    
+    /**
+     * Tests unitaires de 
+     * {@link Contexte#ajouterVariable(Identificateur, Litteral)}
+     */
+    public void testAjouterVariable() {
+        Identificateur[] id = {
+                new IdentificateurChaine("$chaine"), // ajout dans liste vide
+                new IdentificateurEntier("entier"), // ajout fin
+                new IdentificateurChaine("$zoro"),  // ajout milieu
+                // modif variable présente
+                new IdentificateurChaine("$chaine"), // ajout dans liste vide
+                new IdentificateurEntier("entier"), // ajout fin
+                new IdentificateurChaine("$zoro"),  // ajout milieu
+                
+                new IdentificateurChaine("$abcd"),  // ajout debut
+        };
+        
+        Litteral[] valeur = {
+                new Chaine("\"blabla\""),
+                new Entier(25),
+                new Chaine("\"Zoro le héro\""),
+                
+                new Chaine("\"viveLa Vie\""),
+                new Entier(-1),
+                new Chaine("\"   ah ah !  \""),
+                
+                new Chaine("\"lol\""),
+        };
+        
+        System.out.println("\tExécution du test de "
+                + "Contexte#ajouterVariable(Identificateur, Litteral)");
+        
+        for (int numAjout = 0 ; numAjout < id.length ; numAjout++) {
+            fixture[0].ajouterVariable(id[numAjout], valeur[numAjout]);
+            if (numAjout == 2) {
+                System.out.println(fixture[0].toString());
+            }
+        }
+        System.out.println(fixture[0].toString());
+    }
+    
+    /**
+     * Tests unitaires de {@link Contexte#toString()}
+     */
+    public void testToString() {
+        String[] chaineAttendue = {
+                "aucune variable n'est définie\n",
+                "aucune variable n'est définie\n",
+                "aucune variable n'est définie\n",
+                // TODO refaire quand totalement fonctionnel
+        };
+        
+        System.out.println("\tExécution du test de Contexte#toString()");
+        for (int numTest = 0 ; numTest < chaineAttendue.length ; numTest++) {
+            assertEquivalence(fixture[numTest].toString(),
+                              chaineAttendue[numTest]);
+        }
+    }
+    
+    /**
+     * Tests unitaires de {@link Contexte#raz()}
+     */
+    public void testRaz() {
+        String toStringVide = "aucune variable n'est définie\n";
+        
+        // fixture 0 est vide
+        
+        // fixture 1 a 3 éléments à vider
+        fixture[1].ajouterVariable(new IdentificateurChaine("$chaine"), 
+                                   new Chaine("\"blabla\""));
+        fixture[1].ajouterVariable(new IdentificateurEntier("entier"), 
+                                   new Entier(25));
+        fixture[1].ajouterVariable(new IdentificateurChaine("$zoro"), 
+                                   new Chaine("\"Zoro le héro\""));
+        
+        // fixture 2 a 1 éléments unique
+        fixture[1].ajouterVariable(new IdentificateurChaine("$zer"), 
+                                   new Chaine("\"blvzgr\""));
+        
+        System.out.println("\tExécution du test de Contexte#raz()");
+        for (Contexte aTester : fixture) {
+            aTester.raz();
+            // toString doit être celui d'un contexte vide
+            assertEquivalence(toStringVide, aTester.toString());
+        }
+    }
+    
+    /**
+     * Tests unitaire de {@link Contexte#lireValeurVariable(Identificateur)}
+     */
+    public void testLireValeurVariable() {
+
+        System.out.println("\tExécution du test de "
+                           + "Contexte#lireValeurVariable(Identificateur)");
+        
+        // lire valeur défaut contexte vid
+        assertEquivalence(fixture[0].lireValeurVariable(
+                new IdentificateurChaine("$chaine")).getValeur(), "");
+        assertEquivalence(fixture[0].lireValeurVariable(
+                new IdentificateurEntier("entier")).getValeur(), Integer.valueOf(0));
+        
+        // lire valeur par défaut dans contexte non vide
+        fixture[1].ajouterVariable(new IdentificateurChaine("$zoro"), 
+                new Chaine("\"Zoro le héro\""));
+        
+        assertEquivalence(fixture[1].lireValeurVariable(
+                new IdentificateurChaine("$chaine")).getValeur(), "");
+        assertEquivalence(fixture[1].lireValeurVariable(
+                new IdentificateurEntier("entier")).getValeur(), 0);
+        
+        // lire valeur qui existent déjà
+        fixture[1].ajouterVariable(new IdentificateurChaine("$chaine"), 
+                                   new Chaine("\"blabla\""));
+        fixture[1].ajouterVariable(new IdentificateurEntier("entier"), 
+                                   new Entier(25));
+        
+        System.out.println(fixture[1].lireValeurVariable(
+                new IdentificateurChaine("$zoro")).getValeur());
+        
+        
+        assertEquivalence(fixture[1].lireValeurVariable(
+                new IdentificateurChaine("$chaine")).getValeur(), "blabla");
+        assertEquivalence(fixture[1].lireValeurVariable(
+                          new IdentificateurEntier("entier")).getValeur(), 25);
+        assertEquivalence(fixture[1].lireValeurVariable(
+                              new IdentificateurChaine("$zoro")).getValeur(), 
+                          "Zoro le héro");
+
+        
+    }
+}