Contexte et tests

src/src/interpreteurlir/Contexte.java

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

src/src/interpreteurlir/InterpreteurException.java

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

src/src/interpreteurlir/donnees/Variable.java

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

src/src/interpreteurlir/tests/EssaiInterpreteurException.java

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

src/src/interpreteurlir/tests/TestContexte.java

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