lucasvbr/interpreteur-lir
1
0
Fork 0
mirror of https://github.com/LucasVbr/interpreteur-lir.git synced 2026-05-13 17:21:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

Prototype 2.0

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