From 2d5320d87912c9bcc5d55d45ccbf855a3a4879ae Mon Sep 17 00:00:00 2001 From: Tchi Date: Sat, 8 May 2021 13:46:46 +0200 Subject: [PATCH] Identificateur V0 --- src/donnees/Identificateur.java | 22 +++++ src/donnees/IdentificateurChaine.java | 65 +++++++++++++ src/donnees/IdentificateurEntier.java | 93 +++++++++++++++++++ .../tests/TestIdentificateurChaine.java | 83 +++++++++++++++++ .../tests/TestIdentificateurEntier.java | 83 +++++++++++++++++ src/outils/InterpreteurException.java | 25 +++++ src/outils/glg/Assertions.java | 42 +++++++++ src/outils/glg/EchecTest.java | 19 ++++ src/outils/glg/ExecuteurDeTest.java | 86 +++++++++++++++++ 9 files changed, 518 insertions(+) create mode 100644 src/donnees/Identificateur.java create mode 100644 src/donnees/IdentificateurChaine.java create mode 100644 src/donnees/IdentificateurEntier.java create mode 100644 src/donnees/tests/TestIdentificateurChaine.java create mode 100644 src/donnees/tests/TestIdentificateurEntier.java create mode 100644 src/outils/InterpreteurException.java create mode 100644 src/outils/glg/Assertions.java create mode 100644 src/outils/glg/EchecTest.java create mode 100644 src/outils/glg/ExecuteurDeTest.java diff --git a/src/donnees/Identificateur.java b/src/donnees/Identificateur.java new file mode 100644 index 0000000..3567f41 --- /dev/null +++ b/src/donnees/Identificateur.java @@ -0,0 +1,22 @@ +/* + * Identificateur.java , 08/05/2021 + * IUT Rodez 2020-2021, info1 + * pas de copyright, aucun droits + */ + +package donnees; + +/** + * @author Lucàs VABRE + * @author Heïa DEXTER + */ +public class Identificateur /* extends Variable */ { + + /** + * Instanciation de l'identificateur + * @param identificateur + */ + public Identificateur() { + // super(); + } +} diff --git a/src/donnees/IdentificateurChaine.java b/src/donnees/IdentificateurChaine.java new file mode 100644 index 0000000..dbd56fc --- /dev/null +++ b/src/donnees/IdentificateurChaine.java @@ -0,0 +1,65 @@ +/* + * IdentificateurChaine.java, 08/05/2021 + * IUT Rodez 2020-2021, info1 + * pas de copyright, aucun droits + */ + +package donnees; + +/** + * Identificateur de chaine + * @author Lucàs VABRE + * @author Heïa DEXTER + */ +public class IdentificateurChaine extends Identificateur { + + /** Nom identificateur */ + private String nom; + + /** + * Instantiation d'identificateur de chaine + * @param identificateur a instancier + * @throws IllegalAccessException si l'identificateur est invalide + */ + public IdentificateurChaine(String identificateur) { + super(); + + if(!isIdentificateurChaine(identificateur)) { + throw new IllegalArgumentException(identificateur + " n'est pas un identificateur de chaine"); + } + + this.nom = identificateur; + } + + /** + * 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 boolean isIdentificateurChaine(String identificateur) { + boolean testOk = identificateur != null + && identificateur.length() > 0 + && identificateur.charAt(0) == '$'; + + for (int i = 1 ; testOk && i < identificateur.length() ; i++) { + testOk = 'a' <= identificateur.charAt(i) + && identificateur.charAt(i) <= 'z' ; + } + + return testOk; + } + + /* non javadoc - @see java.lang.Object#toString() */ + @Override + public String toString() { + return "IdentificateurChaine [nom=" + nom + "]"; + } + + /** + * @return la valeur de nom + */ + public String getNom() { + return nom; + } +} diff --git a/src/donnees/IdentificateurEntier.java b/src/donnees/IdentificateurEntier.java new file mode 100644 index 0000000..2ff588b --- /dev/null +++ b/src/donnees/IdentificateurEntier.java @@ -0,0 +1,93 @@ +/* + * IdentificateurEntier.java , 08/05/2021 + * IUT Rodez 2020-2021, info1 + * pas de copyright, aucun droits + */ + +package donnees; + +/** + * Identificateur d'entier + * @author Lucàs VABRE + * @author Heïa DEXTER + */ +public class IdentificateurEntier extends Identificateur { + + /** Nom identificateur */ + private String nom; + + /** + * Instantiation d'identificateur d'entier + * @param identificateur a instancier + * @throws IllegalAccessException si l'identificateur est invalide + */ + public IdentificateurEntier(String identificateur) { + super(); + + if(!isIdentificateurEntier(identificateur)) { + throw new IllegalArgumentException(identificateur + " n'est pas un identificateur d'entier"); + } + + this.nom = identificateur; + } + + /** + * 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 boolean isIdentificateurEntier(String identificateur) { + final int LONGUEUR_MAX = 24; + + boolean testOk = identificateur != null + && 0 < identificateur.length() + && identificateur.length() <= LONGUEUR_MAX + && isLettre(identificateur.charAt(0)); + + for (int i = 1 ; testOk && i < identificateur.length() ; i++) { + testOk = isLettre(identificateur.charAt(i)) + || isChiffre(identificateur.charAt(i)); + } + + return testOk; + } + + /** + * Prédicat attestant si un caractère est une lettre + * @param aTester caractère a tester + * @return + */ + private 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 + */ + private static boolean isChiffre(char aTester) { + return '0' <= aTester && aTester <= '9'; + } + + /* non javadoc - @see java.lang.Object#toString() */ + @Override + public String toString() { + return "IdentificateurEntier [nom=" + nom + "]"; + } + + /** + * @return la valeur de nom + */ + public String getNom() { + return nom; + } + +} diff --git a/src/donnees/tests/TestIdentificateurChaine.java b/src/donnees/tests/TestIdentificateurChaine.java new file mode 100644 index 0000000..bba482f --- /dev/null +++ b/src/donnees/tests/TestIdentificateurChaine.java @@ -0,0 +1,83 @@ +/* + * TestIdentificateurChaine.java, 08/05/2021 + * IUT Rodez 2020-2021, info1 + * pas de copyright, aucun droits + */ + +package donnees.tests; + +import static outils.glg.Assertions.assertEquivalent; +import static outils.glg.Assertions.echec; + +import donnees.IdentificateurChaine; + +/** + * Tests unitaires de la classe donnees.IdentificateurEntier + * @author Lucàs VABRE + * @author Heïa DEXTER + */ +public class TestIdentificateurChaine { + /** Jeu d'identificateurs de chaine correctement instanciés */ + private static IdentificateurChaine[] FIXTURE = { + new IdentificateurChaine("$alpha"), + new IdentificateurChaine("$beta"), + new IdentificateurChaine("$gamma") + }; + + /** + * Tests unitaires du constructeur IdentificateurEntier(String identificateur) + */ + public static void testIdentificateurChaineString() { + final String[] INVALIDE = { + "9alpha", + "-beta", + "GAMMA", + "id 3a", + "", + " ", + "\t", + "\n", + null + }; + + 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 = { + "$alpha", + "$beta", + "$gamma" + }; + + for (int noJeu = 0 ; noJeu < NOM_VALIDES.length ; noJeu++) { + assertEquivalent(NOM_VALIDES[noJeu], FIXTURE[noJeu].getNom()); + } + } + + /** + * Tests unitaires de toString + */ + public static void testToString() { + final String[] CHAINES_VALIDES = { + "$alpha", + "$beta", + "$gamma" + }; + + for (int noJeu = 0 ; noJeu < CHAINES_VALIDES.length ; noJeu++) { + assertEquivalent("IdentificateurChaine [nom=" + CHAINES_VALIDES[noJeu] + "]", + FIXTURE[noJeu].toString()); + } + } +} diff --git a/src/donnees/tests/TestIdentificateurEntier.java b/src/donnees/tests/TestIdentificateurEntier.java new file mode 100644 index 0000000..3c8db26 --- /dev/null +++ b/src/donnees/tests/TestIdentificateurEntier.java @@ -0,0 +1,83 @@ +/* + * TestIdentificateurEntier.java , 08/05/2021 + * IUT Rodez 2020-2021, info1 + * pas de copyright, aucun droits + */ + +package donnees.tests; + +import static outils.glg.Assertions.*; + +import donnees.IdentificateurEntier; + +/** + * Tests unitaires de la classe donnees.IdentificateurEntier + * @author Lucàs VABRE + * @author Heïa DEXTER + */ +public class TestIdentificateurEntier { + + /** Jeu d'identificateurs d'entier correctement instanciés */ + private static IdentificateurEntier[] FIXTURE = { + new IdentificateurEntier("alpha"), + new IdentificateurEntier("beta"), + new IdentificateurEntier("gamma") + }; + + /** + * Tests unitaires du constructeur IdentificateurEntier(String identificateur) + */ + public static void testIdentificateurEntierString() { + final String[] INVALIDE = { + "9alpha", + "$beta", + "GAMMA", + "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 = { + "alpha", + "beta", + "gamma" + }; + + for (int noJeu = 0 ; noJeu < NOM_VALIDES.length ; noJeu++) { + assertEquivalent(NOM_VALIDES[noJeu], FIXTURE[noJeu].getNom()); + } + } + + /** + * Tests unitaires de toString + */ + public static void testToString() { + final String[] CHAINES_VALIDES = { + "alpha", + "beta", + "gamma" + }; + + for (int noJeu = 0 ; noJeu < CHAINES_VALIDES.length ; noJeu++) { + assertEquivalent("IdentificateurEntier [nom=" + CHAINES_VALIDES[noJeu] + "]", + FIXTURE[noJeu].toString()); + } + } +} diff --git a/src/outils/InterpreteurException.java b/src/outils/InterpreteurException.java new file mode 100644 index 0000000..5064b10 --- /dev/null +++ b/src/outils/InterpreteurException.java @@ -0,0 +1,25 @@ +/** + * InterpreteurException.java 7 mai 2021 + * IUT Rodez info1 2020-2021, pas de copyright, aucun droit + */ +package outils; + +/** + * Exception levée lors d'une erreur dans l'interpreteur LIR. + * (Erreur de syntaxe, erreur de types) + * @author Nicolas Caminade + * @author Sylvan Courtiol + * @author Pierre Debas + * @author Heïa Dexter + * @author Lucas Vabre + */ +public class InterpreteurException extends RuntimeException { + + /** + * Une exception de syntaxe expliquée par un message + * @param message explication succincte de cette exception + */ + public InterpreteurException(String message) { + super(message); + } +} diff --git a/src/outils/glg/Assertions.java b/src/outils/glg/Assertions.java new file mode 100644 index 0000000..84ca5ae --- /dev/null +++ b/src/outils/glg/Assertions.java @@ -0,0 +1,42 @@ +/* + * Assertions.java 7 avr. 2021 + * IUT info1 2020-2021, groupe 2, aucun droit d'auteur + */ +package outils.glg; + +/** + * Propositions logiques de test qui propage EchecTest + * si elles ne sont pas vérifiées + * @author info1 202-2021 + */ +public class Assertions { + + /** + * Assertion vérifiant qu'une expression booléenne est vraie. + * Ce test échoue si elle est fausse + * @param condition expression booléenne à tester + */ + public static void assertTrue(boolean condition) { + if (!condition) { + throw new EchecTest(); + } + } + + /** + * Assertion testant l'équivalence de 2 objets selon la relation + * d'équivalence de base equals (@see java.lang.Object#equals) + * @param attendu valeur attendue pour le test + * @param obtenu valeur obtenue à tester + */ + public static void assertEquivalent(Object attendu, Object obtenu) { + assertTrue(obtenu.equals(attendu)); + } + + /** + * Echec systématique de test + * (signaler que une série de test est insuffisante) + */ + public static void echec() { + assertTrue(false); + } +} diff --git a/src/outils/glg/EchecTest.java b/src/outils/glg/EchecTest.java new file mode 100644 index 0000000..970b481 --- /dev/null +++ b/src/outils/glg/EchecTest.java @@ -0,0 +1,19 @@ +/* + * EchecTest.java 7 avr. 2021 + * IUT info1 2020-2021, groupe 2, aucun droit d'auteur + */ +package outils.glg; + +/** + * Exception lancée si un test unitaire échoue : comportement obtenu n'étant pas + * le comportement attendu + * @author info1 2020-2021 + */ +public class EchecTest extends RuntimeException { + + // constructeur par défaut généré par le compilateur + public EchecTest() { + super(); + } + +} diff --git a/src/outils/glg/ExecuteurDeTest.java b/src/outils/glg/ExecuteurDeTest.java new file mode 100644 index 0000000..9961c29 --- /dev/null +++ b/src/outils/glg/ExecuteurDeTest.java @@ -0,0 +1,86 @@ +/* + * ExecuteurDeTest.java 13 avr. 2021 + * IUT info1 2020-2021, groupe 2, aucun droit d'auteur + */ +package outils.glg; + +import java.lang.reflect.Method; + + +/** + * Lanceur de test automatique ("test runner") qui exécute les méthodes de tests + * unitaires d'une classe de test telle que : + * + * + * @author info1 2020-2021 + */ +public class ExecuteurDeTest { + + /** préfixe des méthodes de tests unitaires à lancer */ + public final static String PREFIXE_TEST = "test"; + + /** Code erreur si la ligne de commande est mal formatée */ + public static final int ERR_NB_ARGUMENT = 1; + + /** Code erreur si la classe de test (argument) n'est pas trouvée */ + public static final int ERR_CLASSE_INACCESSIBLE = 2; + + /** Message d'aide à l'usage de l'outil */ + private static final String MESSAGE_USAGE + = "usage : info1.outils.glg.ExecuteurDeTest nom.complet.de.classe.de.Test"; + + /** + * Lancement automatique des méthodes de test + * d'une classe de test passée en argument + * @param args nom java complet de la classe de test à exécuter + */ + public static void main(String[] args) { + + /* Analyse de la ligne de commande */ + if (args.length != 1) { + System.err.println("Nombre d'arguments incorrects"); + System.err.println(MESSAGE_USAGE); + System.exit(ERR_NB_ARGUMENT); + } + Class deTest = null; + try { + deTest = Class.forName(args[0]); + } catch (ClassNotFoundException e) { + System.err.println("Classe " + args[0] + " non accessible"); + System.err.println(MESSAGE_USAGE); + System.exit(ERR_CLASSE_INACCESSIBLE); + } + + /* Lancement des méthodes de tests unitaires */ + Method[] aFiltrer = deTest.getDeclaredMethods(); + for (Method aExecuter : aFiltrer) { + String nomMethode = aExecuter.getName(); + if (nomMethode.startsWith(PREFIXE_TEST)) { + try { + aExecuter.invoke(deTest.getConstructor().newInstance()); + /* test Ok */ + System.out.println("Réussite de " + nomMethode); + } catch (Exception aAnalyser) { + if (aAnalyser.getCause() instanceof EchecTest) { + System.out.println("Echec de " + nomMethode); + } else { + System.err.println("Crash de " + nomMethode + " : " + + aAnalyser.getCause().getMessage()); + } + } + System.out.println("-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-"); + } + } + } +}