diff --git a/src/.gitignore b/src/.gitignore deleted file mode 100644 index dce8342..0000000 --- a/src/.gitignore +++ /dev/null @@ -1,7 +0,0 @@ -# ignore les fichiers non nécessaire TexStudio -*.synctex.gz -*.aux -*.log -*.out -*.toc - diff --git a/src/interpreteurlir/InterpreteurException.java b/src/interpreteurlir/InterpreteurException.java new file mode 100644 index 0000000..e95ab9b --- /dev/null +++ b/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); + } +} diff --git a/src/interpreteurlir/expressions/Expression.java b/src/interpreteurlir/expressions/Expression.java new file mode 100644 index 0000000..0d85509 --- /dev/null +++ b/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 + */ + 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; + } +} diff --git a/src/interpreteurlir/expressions/ExpressionChaine.java b/src/interpreteurlir/expressions/ExpressionChaine.java new file mode 100644 index 0000000..3be9f18 --- /dev/null +++ b/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"; + } + +} diff --git a/src/interpreteurlir/expressions/ExpressionEntier.java b/src/interpreteurlir/expressions/ExpressionEntier.java new file mode 100644 index 0000000..99b3610 --- /dev/null +++ b/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"; + } + +} \ No newline at end of file diff --git a/src/interpreteurlir/expressions/tests/ExpressionEntier.java b/src/interpreteurlir/expressions/tests/ExpressionEntier.java new file mode 100644 index 0000000..7c693ca --- /dev/null +++ b/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 { + +} diff --git a/src/interpreteurlir/expressions/tests/TestExpression.java b/src/interpreteurlir/expressions/tests/TestExpression.java new file mode 100644 index 0000000..a877a51 --- /dev/null +++ b/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 { + +} diff --git a/src/interpreteurlir/expressions/tests/TestExpressionChaine.java b/src/interpreteurlir/expressions/tests/TestExpressionChaine.java new file mode 100644 index 0000000..0ef8aa6 --- /dev/null +++ b/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 { + +} diff --git a/src/interpreteurlir/motscles/Commande.java b/src/interpreteurlir/motscles/Commande.java new file mode 100644 index 0000000..36e102b --- /dev/null +++ b/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 + } + + + +} diff --git a/src/interpreteurlir/motscles/CommandeDebut.java b/src/interpreteurlir/motscles/CommandeDebut.java new file mode 100644 index 0000000..8019eda --- /dev/null +++ b/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 : + * + * @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; + } + +} diff --git a/src/interpreteurlir/motscles/CommandeDefs.java b/src/interpreteurlir/motscles/CommandeDefs.java new file mode 100644 index 0000000..24ed2c4 --- /dev/null +++ b/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; + } + + +} diff --git a/src/interpreteurlir/motscles/CommandeFin.java b/src/interpreteurlir/motscles/CommandeFin.java new file mode 100644 index 0000000..0f33707 --- /dev/null +++ b/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; + } +} diff --git a/src/interpreteurlir/motscles/tests/EssaiCommande.java b/src/interpreteurlir/motscles/tests/EssaiCommande.java new file mode 100644 index 0000000..f8bdf7f --- /dev/null +++ b/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()); + } + +} diff --git a/src/interpreteurlir/motscles/tests/TestCommande.java b/src/interpreteurlir/motscles/tests/TestCommande.java new file mode 100644 index 0000000..1afad62 --- /dev/null +++ b/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()); + } + } +} diff --git a/src/interpreteurlir/motscles/tests/TestCommandeDebut.java b/src/interpreteurlir/motscles/tests/TestCommandeDebut.java new file mode 100644 index 0000000..b69546f --- /dev/null +++ b/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()); + } + + } +} diff --git a/src/interpreteurlir/motscles/tests/TestCommandeDefs.java b/src/interpreteurlir/motscles/tests/TestCommandeDefs.java new file mode 100644 index 0000000..1aa4119 --- /dev/null +++ b/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()); + } + + } +} diff --git a/src/interpreteurlir/motscles/tests/TestCommandeFin.java b/src/interpreteurlir/motscles/tests/TestCommandeFin.java new file mode 100644 index 0000000..327d758 --- /dev/null +++ b/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(); + } +} diff --git a/src/interpreteurlir/tests/EssaiInterpreteurException.java b/src/interpreteurlir/tests/EssaiInterpreteurException.java new file mode 100644 index 0000000..a9b9f86 --- /dev/null +++ b/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()); + } + } + } + +}