Commandes et bouchon Expressions

src/.gitignore

@@ -1,7 +0,0 @@
-# ignore les fichiers non nécessaire TexStudio
-*.synctex.gz
-*.aux
-*.log
-*.out
-*.toc
-

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/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/ExpressionEntier.java

@@ -0,0 +1,19 @@
+/**
+ * ExpressionEntier.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 ExpressionEntier {
+
+}

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/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.println(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());
+            }
+        }
+    }
+
+}