Mise en commun pour même base

src/interpreteurlir/donnees/Identificateur.java

@@ -0,0 +1,128 @@
+/*
+ * Identificateur.java , 08/05/2021
+ * IUT Rodez 2020-2021, info1
+ * pas de copyright, aucun droits
+ */
+
+package interpreteurlir.donnees;
+
+/**
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class Identificateur /* extends Variable */
+implements Comparable<Identificateur> {
+    
+    /** Longueur maximale d'un identificateur (ne prend pas en compte le $) */
+        public static final int LONGUEUR_MAX = 24;
+        
+        /** Nom identificateur */
+    private String nom;
+        
+    /**
+     * Instantiation de l'identificateur
+     * @param identificateur
+     */
+        public Identificateur(String identificateur) {
+                super();
+                if(!isIdentificateur(identificateur)) {
+                    throw new IllegalArgumentException(identificateur
+                                                       + " n'est pas un identificateur");
+                }
+                
+                nom = identificateur;
+        }
+        
+        /**
+         * Prédicat qui vérifie si une chaîne correspond à un identificateur
+         * <ul>
+         *     <li>Longueur comprise entre 1 et 24 caractères</li>
+         *     <li>N'est pas une chaîne vide</li>
+         *     <li>N'est pas null</li>
+         * </ul>
+         * @param aComparer
+         * @return true si le prédicat est vérifié
+         *         false sinon
+         */
+        public static boolean isIdentificateur(String aComparer) {
+                return aComparer != null
+                       && aComparer.length() > 0
+                       && !removeDollar(aComparer).isBlank()
+                       && removeDollar(aComparer).length() <= LONGUEUR_MAX
+                       && isAlphanumerique(removeDollar(aComparer));
+        }
+        
+        /**
+         * Supprime le caractère $ si il est présent en premier dans la chaîne
+         * @param chaine a modifier
+         * @return la chaîne modifiée
+         */
+        public static String removeDollar(String chaine) {
+            if(chaine.charAt(0) == '$') return chaine.substring(1);
+            return chaine;
+        }
+        
+        /**
+         * Prédicat testant si une chaîne est composée de chiffre ou de lettres
+         * @param aTester chaîne a tester
+         * @return true si le prédicat est vérifié
+         *         false sinon
+         */
+        public static boolean isAlphanumerique(String aTester) {
+                int index;
+                
+                for (index = 0 ;
+                         index < aTester.length()
+                         && (isLettre(aTester.charAt(index))
+                                 || isChiffre(aTester.charAt(index)));
+                         index++)
+                ;    // Corps vide
+                
+                return index >= aTester.length();
+        }
+        
+        /**
+         * Prédicat attestant si un caractère est une lettre
+         * @param aTester caractère a tester
+         * @return true si le prédicat est vérifié
+         *         false sinon
+         */
+        public static boolean isLettre(char aTester) {
+                return 'a' <= aTester && aTester <= 'z'
+                           || 'A' <= aTester && aTester <= 'Z';
+        }
+        
+        /**
+         * Prédicat attestant si un caractère est un chiffre
+         * @param aTester caractère a tester
+         * @return true si le prédicat est vérifié
+         *         false sinon
+         */
+        public static boolean isChiffre(char aTester) {
+                return '0' <= aTester && aTester <= '9';
+        }
+        
+        /**
+     * @return la valeur de nom
+     */
+    public String getNom() {
+        return nom;
+    }
+
+    /* non javadoc - @see java.lang.Object#toString() */
+    @Override
+    public String toString() {
+        return nom;
+    }
+
+    /* non javadoc - @see java.lang.String#Comparable() */
+    @Override
+    public int compareTo(Identificateur aComparer) {
+        return nom.compareTo(aComparer.nom);
+    }
+    
+    
+}

src/interpreteurlir/donnees/IdentificateurChaine.java

@@ -0,0 +1,46 @@
+/*
+ * IdentificateurChaine.java, 08/05/2021
+ * IUT Rodez 2020-2021, info1
+ * pas de copyright, aucun droits
+ */
+
+package interpreteurlir.donnees;
+
+/**
+ * Identificateur de chaîne
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class IdentificateurChaine extends Identificateur {
+
+    /**
+         * Instantiation d'identificateur de chaîne
+         * @param identificateur a instancier
+         * @throws IllegalAccessException si l'identificateur est invalide
+         */
+        public IdentificateurChaine(String identificateur) {
+                super(identificateur);
+                
+                if(!isIdentificateurChaine(identificateur)) {
+                        throw new IllegalArgumentException(identificateur
+                                                           + " n'est pas un identificateur"
+                                                           + " de chaine");
+                }
+        }
+        
+        /**
+         * Prédicat attestant la validité de l'identificateur
+         * @param identificateur à tester
+         * @return true si l'identificateur est bien un identificateur d'entier
+         *                 false sinon
+         */
+        private static boolean isIdentificateurChaine(String identificateur) {
+
+                return identificateur.length() >= 2
+               && identificateur.charAt(0) == '$'
+               && isLettre(identificateur.charAt(1));
+        }
+}

src/interpreteurlir/donnees/IdentificateurEntier.java

@@ -0,0 +1,51 @@
+/*
+ * IdentificateurEntier.java , 08/05/2021
+ * IUT Rodez 2020-2021, info1
+ * pas de copyright, aucun droits
+ */
+
+package interpreteurlir.donnees;
+
+/**
+ * Identificateur d'entier
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class IdentificateurEntier extends Identificateur {
+
+        /**
+         * Instantiation d'identificateur d'entier
+         * @param identificateur a instancier
+         * @throws IllegalAccessException si l'identificateur est invalide
+         */
+        public IdentificateurEntier(String identificateur) {
+                super(identificateur);
+                
+                if(!isIdentificateurEntier(identificateur)) {
+                        throw new IllegalArgumentException(identificateur
+                                                           + " n'est pas un identificateur"
+                                                           + " d'entier");
+                }
+        }
+        
+        /**
+         * Prédicat attestant la validité de l'identificateur
+         * 
+         * Un identificateur d'entier est valide si
+         * - Il contient au maximum 24 caractères
+         * - Commence obligatoirement par une lettre (majuscule ou minuscule)
+         * - suivie uniquement de lettres (majuscule ou minuscule) ou de chiffres
+         * 
+         * @param identificateur à tester
+         * @return true si l'identificateur est bien un identificateur d'entier
+         *                 false sinon
+         */
+        private static boolean isIdentificateurEntier(String identificateur) {
+        
+                return isLettre(identificateur.charAt(0))
+               && isAlphanumerique(identificateur.substring(1));
+        }
+}

src/interpreteurlir/donnees/Variable.java

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

src/interpreteurlir/donnees/litteraux/Chaine.java

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

src/interpreteurlir/donnees/litteraux/Entier.java

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

src/interpreteurlir/donnees/litteraux/Litteral.java

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

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

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

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

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

src/interpreteurlir/donnees/tests/TestIdentificateur.java

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

src/interpreteurlir/donnees/tests/TestIdentificateurChaine.java

@@ -0,0 +1,92 @@
+/*
+ * TestIdentificateurChaine.java, 08/05/2021
+ * IUT Rodez 2020-2021, info1
+ * pas de copyright, aucun droits
+ */
+
+package interpreteurlir.donnees.tests;
+
+import static info1.outils.glg.Assertions.*;
+
+import interpreteurlir.donnees.IdentificateurChaine;
+
+/**
+ * Tests unitaires de la classe donnees.IdentificateurEntier
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class TestIdentificateurChaine {
+	/** Jeu d'identificateurs de chaîne correctement instanciés */
+    private static IdentificateurChaine[] FIXTURE = {
+            new IdentificateurChaine("$a"),
+            new IdentificateurChaine("$A"),
+            new IdentificateurChaine("$alpha"),
+            new IdentificateurChaine("$Alpha"),
+            new IdentificateurChaine("$Alpha5"),
+            new IdentificateurChaine("$jeSuisUnTresLongIdentifi")
+	};
+    
+    /**
+     * Tests unitaires du constructeur IdentificateurEntier(String identificateur)
+     */
+    public static void testIdentificateurChaineString() {
+    	final String[] INVALIDE = {
+    	    null,
+    	    "",
+    	    
+    	    // Commence par une lettre
+            "9alpha",
+            "  5alpha",
+                
+            // Fait au maximum 24 caractères
+            "$jeSuisUnTresLongIdentificateur", // 30 char
+            "$jeSuisUnTresLongIdentific",
+                
+            // Espaces
+            "id 3a",
+            "$id 3a",
+            " ",
+            "$ ",
+            
+            // caractères d'échapements
+            "\t",
+            "\n",
+            "$\t",
+            "$\n",
+            
+            // , cas particulier
+            "$",
+            "$1"
+    	};
+    	
+    	for(int noJeu = 0; noJeu < INVALIDE.length ; noJeu++) {
+    		try {
+    			new IdentificateurChaine(INVALIDE[noJeu]);
+    			echec();
+    		} catch (IllegalArgumentException lancee) {
+    			// test OK
+    		}
+    	}
+    }
+    
+    /**
+     * Tests unitaires de getNom()
+     */
+    public static void testGetNom() {
+        final String[] NOM_VALIDES = {
+            "$a",
+            "$A",
+            "$alpha",
+            "$Alpha",
+            "$Alpha5",
+            "$jeSuisUnTresLongIdentifi"
+        };
+    	
+    	for (int noJeu = 0 ; noJeu < NOM_VALIDES.length ; noJeu++) {
+    		assertEquivalence(NOM_VALIDES[noJeu], FIXTURE[noJeu].getNom());
+    	}
+    }
+}

src/interpreteurlir/donnees/tests/TestIdentificateurEntier.java

@@ -0,0 +1,83 @@
+/*
+ * TestIdentificateurEntier.java , 08/05/2021
+ * IUT Rodez 2020-2021, info1
+ * pas de copyright, aucun droits
+ */
+
+package interpreteurlir.donnees.tests;
+
+import static info1.outils.glg.Assertions.*;
+
+import interpreteurlir.donnees.IdentificateurEntier;
+
+/**
+ * Tests unitaires de la classe donnees.IdentificateurEntier
+ * @author Nicolas Caminade
+ * @author Sylvan Courtiol
+ * @author Pierre Debas
+ * @author Heia Dexter
+ * @author Lucas Vabre
+ */
+public class TestIdentificateurEntier {
+	
+	/** Jeu d'identificateurs d'entier correctement instanciés */
+    private static IdentificateurEntier[] FIXTURE = {
+            new IdentificateurEntier("a"),
+            new IdentificateurEntier("A"),
+            new IdentificateurEntier("alpha"),
+            new IdentificateurEntier("Alpha"),
+            new IdentificateurEntier("Alpha5"),
+            new IdentificateurEntier("jeSuisUnTresLongIdentifi")
+	};
+    
+    /**
+     * Tests unitaires du constructeur IdentificateurEntier(String identificateur)
+     */
+    public static void testIdentificateurEntierString() {
+    	final String[] INVALIDE = {
+    		// Commence par une lettre
+    		"9alpha",
+    		"  5alpha",
+    		"$beta",
+    		
+    		// Fait au maximum 24 caractères
+    		"jeSuisUnTresLongIdentificateur", // 30 char
+    		"jeSuisUnTresLongIdentific",
+    		
+    		// Espaces, caractères d'échapements, cas particulier
+    		"id 3a",
+    		"",
+    		" ",
+    		"\t",
+    		"\n",
+    		null
+    	};
+    	
+    	for(int noJeu = 0; noJeu < INVALIDE.length ; noJeu++) {
+    		try {
+    			new IdentificateurEntier(INVALIDE[noJeu]);
+    			echec();
+    		} catch (IllegalArgumentException lancee) {
+    			// test OK
+    		}
+    	}
+    }
+    
+    /**
+     * Tests unitaires de getNom()
+     */
+    public static void testGetNom() {
+    	final String[] NOM_VALIDES = {
+    			"a",
+    		    "A",
+    		    "alpha",
+    		    "Alpha",
+    		    "Alpha5",
+    		    "jeSuisUnTresLongIdentifi"
+    	};
+    	
+    	for (int noJeu = 0 ; noJeu < NOM_VALIDES.length ; noJeu++) {
+    		assertEquivalence(NOM_VALIDES[noJeu], FIXTURE[noJeu].getNom());
+    	}
+    }
+}