diff --git a/Automate/JFLAP7.1.jar b/Automate/JFLAP7.1.jar new file mode 100644 index 0000000..e4284fd Binary files /dev/null and b/Automate/JFLAP7.1.jar differ diff --git a/Automate/TP0/Ex1.jff b/Automate/TP0/Ex1.jff new file mode 100644 index 0000000..bc4bd92 --- /dev/null +++ b/Automate/TP0/Ex1.jff @@ -0,0 +1,554 @@ + + fa + + + + 67.0 + 48.0 + + + 223.0 + 46.0 + + + 60.0 + 191.0 + + + 219.0 + 189.0 + + + 384.0 + 188.0 + + + + 56.0 + 348.0 + + + 220.0 + 353.0 + + + 374.0 + 353.0 + + + + 48.0 + 485.0 + + + 219.0 + 487.0 + + + + 391.0 + 46.0 + + + + 32.0 + 601.0 + + + 185.0 + 696.0 + + + 186.0 + 835.0 + + + 333.0 + 598.0 + + + + 483.0 + 775.0 + + + + 589.0 + 349.0 + + + + 769.0 + 349.0 + + + 679.0 + 495.0 + + + 572.0 + 92.0 + + + 704.0 + 14.0 + + + 829.0 + 93.0 + + + 827.0 + 211.0 + + + 703.0 + 266.0 + + + 569.0 + 228.0 + + + + 596.0 + 598.0 + + + 801.0 + 597.0 + + + 699.0 + 744.0 + + + + 698.0 + 597.0 + + + 1083.0 + 190.0 + + + + 1246.0 + 59.0 + + + 1254.0 + 196.0 + + + 1251.0 + 334.0 + + + 1485.0 + 57.0 + + + + 1481.0 + 196.0 + + + + 1479.0 + 338.0 + + + + + 21 + 19 + c + + + 8 + 9 + b + + + 17 + 18 + a + + + 29 + 31 + b + + + 17 + 18 + b + + + 17 + 18 + c + + + 35 + 32 + a + + + 32 + 35 + c + + + 35 + 32 + b + + + 2 + 3 + a + + + 31 + 34 + b + + + 34 + 31 + c + + + 34 + 31 + a + + + 5 + 6 + a + + + 6 + 5 + b + + + 0 + 1 + a + + + 29 + 32 + c + + + 0 + 1 + b + + + 20 + 21 + a + + + 18 + 16 + c + + + 18 + 16 + b + + + 18 + 16 + a + + + 33 + 30 + b + + + 33 + 30 + c + + + 30 + 33 + a + + + 21 + 22 + b + + + 6 + 7 + a + + + 27 + 28 + a + + + 3 + 4 + a + + + 20 + 19 + c + + + 20 + 19 + b + + + 19 + 20 + a + + + 14 + 12 + b + + + 28 + 26 + b + + + 11 + 12 + b + + + 22 + 19 + a + + + 16 + 17 + c + + + 16 + 17 + b + + + 29 + 30 + a + + + 16 + 17 + a + + + 22 + 19 + b + + + 1 + 10 + b + + + 12 + 13 + a + + + 22 + 23 + c + + + 25 + 28 + a + + + 1 + 10 + a + + + 9 + 9 + a + + + 7 + 7 + a + + + 11 + 11 + a + + + 24 + 24 + a + + + 21 + 21 + a + + + 31 + 31 + a + + + 32 + 32 + a + + + 33 + 33 + a + + + 3 + 3 + b + + + 4 + 4 + b + + + 9 + 9 + b + + + 12 + 12 + b + + + 7 + 7 + b + + + 34 + 34 + b + + + 2 + 2 + b + + + 5 + 5 + b + + + 19 + 19 + b + + + 32 + 32 + b + + + 24 + 24 + b + + + 30 + 30 + b + + + 19 + 19 + c + + + 24 + 24 + c + + + 30 + 30 + c + + + 31 + 31 + c + + + 35 + 35 + c + + + 23 + 19 + b + + + 23 + 19 + a + + + 13 + 11 + a + + + 23 + 24 + c + + + 13 + 14 + b + + + 26 + 27 + c + + + 14 + 11 + a + + + \ No newline at end of file diff --git a/Automate/TP0/Ex2.jff b/Automate/TP0/Ex2.jff new file mode 100644 index 0000000..6841b20 --- /dev/null +++ b/Automate/TP0/Ex2.jff @@ -0,0 +1,296 @@ + + fa + + + + 239.0 + 109.0 + + + 96.0 + 289.0 + + + + 426.0 + 114.0 + + + + 100.0 + 107.0 + + + 240.0 + 288.0 + + + + 389.0 + 289.0 + + + + 63.0 + 465.0 + + + 253.0 + 401.0 + + + 248.0 + 522.0 + + + + 391.0 + 459.0 + + + 632.0 + 89.0 + + + + 888.0 + -64.0 + + + 930.0 + 301.0 + + + 1119.0 + -61.0 + + + 950.0 + 119.0 + + + 1079.0 + 124.0 + + + 1202.0 + 309.0 + + + 1316.0 + 111.0 + + + 766.0 + 181.0 + + + + 771.0 + 15.0 + + + + 17 + 16 + 0 + + + 14 + 19 + 0 + + + 8 + 9 + 0 + + + 9 + 8 + 0 + + + 3 + 0 + a + + + 13 + 18 + 1 + + + 15 + 13 + 1 + + + 18 + 19 + 1 + + + 10 + 18 + 0 + + + 19 + 11 + 0 + + + 19 + 12 + 1 + + + 1 + 4 + 1 + + + 11 + 13 + 0 + + + 0 + 2 + b + + + 2 + 0 + a + + + 12 + 15 + 0 + + + 15 + 12 + 0 + + + 0 + 0 + a + + + 2 + 2 + b + + + 4 + 5 + 0 + + + 5 + 4 + 1 + + + 13 + 17 + 0 + + + 7 + 8 + 1 + + + 8 + 7 + 1 + + + 11 + 14 + 1 + + + 14 + 11 + 1 + + + 16 + 14 + 0 + + + 10 + 19 + 1 + + + 16 + 15 + 1 + + + 6 + 8 + 1 + + + 1 + 1 + 0 + + + 5 + 5 + 0 + + + 7 + 7 + 0 + + + 18 + 18 + 795 + 188 + 0 + + + 4 + 4 + 1 + + + 9 + 9 + 1 + + + 17 + 17 + 1 + + + 6 + 7 + 0 + + + 12 + 16 + 1 + + + + 286.0 + 756.0 + + + \ No newline at end of file diff --git a/Automate/TP0/TP2NDA.jff b/Automate/TP0/TP2NDA.jff new file mode 100644 index 0000000..2d35623 --- /dev/null +++ b/Automate/TP0/TP2NDA.jff @@ -0,0 +1,73 @@ + + fa + + + + 67.0 + 118.0 + + + + 148.0 + 51.0 + + + 149.0 + 162.0 + + + 261.0 + 49.0 + + + 262.0 + 162.0 + + + 382.0 + 51.0 + + + + 388.0 + 166.0 + + + + + 4 + 6 + a + + + 0 + 0 + b + + + 0 + 2 + a + + + 2 + 4 + a + + + 1 + 3 + b + + + 0 + 1 + a + + + 3 + 5 + b + + + \ No newline at end of file diff --git a/Automate/TP0/n2n2n+1 b/Automate/TP0/n2n2n+1 new file mode 100644 index 0000000..47d75a9 --- /dev/null +++ b/Automate/TP0/n2n2n+1 @@ -0,0 +1,20 @@ +n 2n 2n+1 +0 mod3 0 mod3 1 mod3 +1 mod3 2 mod3 0 mod3 +2 mod3 1 mod3 2 mod3 + + 0 1 +zéro zéro un +un deux zéro +deux un deux + +n 2n 2n+1 +0 mod9 0 mod9 1 mod9 +1 mod9 2 mod9 3 mod9 +2 mod9 4 mod9 5 mod9 +3 mod9 6 mod9 7 mod9 +4 mod9 8 mod9 0 mod9 +5 mod9 1 mod9 2 mod9 +6 mod9 3 mod9 4 mod9 +7 mod9 5 mod9 6 mod9 +8 mod9 7 mod9 8 mod9 \ No newline at end of file diff --git a/DEV3.2/ControleMachine/ARemplirDEV32.tar.gz b/DEV3.2/ControleMachine/ARemplirDEV32.tar.gz new file mode 100644 index 0000000..df9a5d9 Binary files /dev/null and b/DEV3.2/ControleMachine/ARemplirDEV32.tar.gz differ diff --git a/DEV3.2/ControleMachine/DEV32/1/Bulles.java b/DEV3.2/ControleMachine/DEV32/1/Bulles.java new file mode 100644 index 0000000..18f98c5 --- /dev/null +++ b/DEV3.2/ControleMachine/DEV32/1/Bulles.java @@ -0,0 +1,55 @@ +/** + * @author Pourchot Adrian + */ + +import java.util.*; + +public class Bulles{ + + public static boolean bulle(ArrayDeque listerempli, ArrayDeque listevide){ + int stockentier=listerempli.remove(); + boolean ordrechanger=false; + + + while(!listerempli.isEmpty()){ + if(stockentier>listerempli.element()){ + listevide.add(listerempli.remove()); + ordrechanger=true; + } + else{ + listevide.add(stockentier); + stockentier=listerempli.remove(); + } + } + listevide.add(stockentier); + return ordrechanger; + } + + public static void tri(ArrayDeque listeatrier){ + ArrayDeque listeentiervide = new ArrayDeque(10); + boolean boucle=true; + + while(boucle){ + boucle=bulle(listeatrier,listeentiervide); + while(!listeentiervide.isEmpty()){ + listeatrier.add(listeentiervide.remove()); + } + } + } + + public static void main(String[] args) { + ArrayDeque listeentier = new ArrayDeque(10); + int affichage; + + for (int i=0; i d = new SimpleDequeThatsNotCricket(); + + System.out.println(d.toString());// + System.out.println(""); + + String s = "Zo"; + System.out.println("addFirst " + s);// + d.addFirst(s); + System.out.println(d.toString());// + + s = "Bu"; + System.out.println("addFirst " + s);// + d.addFirst(s); + System.out.println(d.toString());// + + s = "Ga"; + System.out.println("addFirst " + s);// + d.addFirst(s); + System.out.println(d.toString());// + + s = "Meu"; + System.out.println("addLast " + s);// + d.addLast(s); + System.out.println(d.toString());//gab + System.out.println(""); + + System.out.println("removeFirst "+d.removeFirst()+", reste"); + System.out.println(d.toString());//Ga + System.out.println("removeLast "+d.removeLast()+", reste"); + System.out.println(d.toString());//Meu + System.out.println("removeLast "+d.removeLast()+", reste"); + System.out.println(d.toString());//Zo + System.out.println("removeFirst "+d.removeFirst()+", reste"); + System.out.println(d.toString());//Bu + System.out.println(""); + + + } + +} diff --git a/DEV3.2/ControleMachine/DEV32/2/MinimalDeque.java b/DEV3.2/ControleMachine/DEV32/2/MinimalDeque.java new file mode 100644 index 0000000..e1b75ca --- /dev/null +++ b/DEV3.2/ControleMachine/DEV32/2/MinimalDeque.java @@ -0,0 +1,68 @@ +/** + * interface simplifiée pour un Deque, c'est-à-dire une file d'attente à double extrémité + * + * Pour éviter la lourdeur de l'interface Deque de l'API officielle, celle-ci limite + * cette dernière à 5 méthodes essentielles. + * + * La spécification de ces méthodes est essentiellement identique à celle des méthodes équivalentes + * dans Deque. + * + * Ici nous choisissons d'interdire null comme élément et de ne pas limiter la capacité de la deque. + * Nous ignorons ClassCastException qui n'est a priori pas possible d'obtenir en runtime avec javac sans contorsion. + * + * The javadoc is reproduced and adapted from source for your convenience below in the file, but in english. + * + * Il est recommandé d'ajouter un constructeur sans argument qui instancie un deque vide. + * Il est utile de surcharger toString() pour permettre d'afficher utilement la structure de donnée. + *Œ + * @author Luc Hernandez, Florent Madelaine. + * @See Java.util.Deque + */ + +public interface MinimalDeque { + + /** + * Inserts the specified element at the front of this deque if it is + * possible to do so. + * + * @param e the element to add + * @throws NullPointerException if the specified element is null + * @throws IllegalArgumentException if some property of the specified + * element prevents it from being added to this deque + */ + void addFirst(E e); + + /** + * Inserts the specified element at the end of this deque if it is + * possible to do so. + * + * @param e the element to add + * @throws NullPointerException if the specified element is null + * @throws IllegalArgumentException if some property of the specified + * element prevents it from being added to this deque + */ + void addLast(E e); + + /** + * Returns true if this collection contains no elements. + * + * @return true if this collection contains no elements + */ + boolean isEmpty(); + + /** + * Retrieves and removes the first element of this deque. + * + * @return the head of this deque + * @throws NoSuchElementException if this deque is empty + */ + E removeFirst(); + + /** + * Retrieves and removes the last element of this deque. + * + * @return the tail of this deque + * @throws NoSuchElementException if this deque is empty + */ + E removeLast(); +} diff --git a/DEV3.2/ControleMachine/DEV32/2/QuestionsTest.txt b/DEV3.2/ControleMachine/DEV32/2/QuestionsTest.txt new file mode 100644 index 0000000..930c381 --- /dev/null +++ b/DEV3.2/ControleMachine/DEV32/2/QuestionsTest.txt @@ -0,0 +1,65 @@ +Ce fichier indiquent les questions à résoudre pour la partie test du TP noté. +Il faudra soit éditer les squelette de fichiers java fournis, soit répondre dans ce fichier sous la question. + +1) [3 points en tout] + + La classe SimpleDequeThatsNotCricket implémente l'interface MinimalDeque demandée. + L'expression britannique "that's not cricket" se traduit par "ce n'est pas du jeux". + En effet, cette classe fait exactement ce qu'il ne faut pas faire puisqu'elle utilise + une implémentation de Deque fournies par java.util. + + a) Quel patron de conception est à l'oeuvre ici? + [2 points] + + Il s'agit d'une façade. + + b) Comment fonctionne cette classe? + [1 point] + + Elle implémente et redéfinit les méthodes contenu dans l'interfaces MinimalDeque tout en ajoutant de nouvelles méthodes propre à elle même. + +2) [-6 à 4 points en tout] + + Indiquez pour chaque assertion si elles est vraie ou non. + + [2 points par groupe d'assertion si toutes correctes, + -1 si une faute par question, + 0 si pas répondu)] + + a1) Il est possible de décider si un programme java va s'arrêter quelle que soit son entrée. + V/F + a2) Il est possible de décider si un programme C va s'arrêter quelle que soit son entrée. + V/F + a3) Il est possible de décider si un programme python ne va pas s'arrêter pour certaines entrées. + V/F + + b1) Il est possible de décrire les propriétés souhaitées d'un programme en utilisant + des langages de spécifications inspirés de la logique du premier ordre. + V/F + b2) Il existe des logiciels qui étant donné une spécification et un programme peuvent + décider à coup sûr que le programme satisfait la spécification ou pas. + V/F + b3) Il existe des logiciels qui étant donné une spécification et un programme peuvent + décider si le programme satisfait la spécification ou pas en demandant + à un logiciel d'IA générative (comme chatGPT) pour générer une preuve. + V/F + +3) [1 point en tout] + + a) Quelle est la commande pour lancer les tests de la classe TestSimpleDeque si les archives + junit.jar et hamcrest-core.jar sont dans le même répertoire? + + java junit.jar hamcrest-core.jar TestSimpleDeque + + b) Quelle est la commande pour lancer les tests de la classe TestSimpleDeque si les archives + junit.jar et hamcrest-core.jar sont dans le CLASSPATH? + + java org.junit.runner.JUnitCore TestSimpleDeque + +4) [12 points en tout] + + Remplissez les tests dans TestSimpleDeque.java + + Il faut absolument que ce fichier compile sinon c'est 0 pour cette partie. + voir barème dans TestSimpleDeque pour chaque test. + diff --git a/DEV3.2/ControleMachine/DEV32/2/README.txt b/DEV3.2/ControleMachine/DEV32/2/README.txt new file mode 100644 index 0000000..676fdec --- /dev/null +++ b/DEV3.2/ControleMachine/DEV32/2/README.txt @@ -0,0 +1,20 @@ +Contenu du répertoire. + +README.txt ce fichier. +838_planche06_copie.webp vive les shadocks + +MinimalDeque.java interface minimale d'un deque +SimpleDequeThatsNotCricket.java implémentation qui triche +Exemple.java exemple d'usage + + +SimpleDeque.java fichier à rendre pour Luc + +QuestionsTest.txt Fichier à remplir pour Florent +TestSimpleDeque.java Fichier à remplir pour Florent + + +Pour utiliser JUnit : + +Attention à vérifier votre CLASSPATH qui doit contenir le jar pour junit4 et potentiellement celui de hamcrest si vous souhaitez utiliser des mécanismes d'assertions plus avancés. + diff --git a/DEV3.2/ControleMachine/DEV32/2/SimpleDeque.java b/DEV3.2/ControleMachine/DEV32/2/SimpleDeque.java new file mode 100644 index 0000000..9834f98 --- /dev/null +++ b/DEV3.2/ControleMachine/DEV32/2/SimpleDeque.java @@ -0,0 +1,45 @@ +/** + * Implémentation de l'interface MinimalDeque + * + * classe à rendre à luc. + * + * @author Pourchot Adrian + * @see Java.util.Deque + */ +public class SimpleDeque implements MinimalDeque{ + + private E[] deque; + + public SimpleDeque(){ + this.deque = new E[0]; + } + + public void addFirst(E e){ + Objects.requireNonNull(e, "e must not be null"); + + } + + public void addLast(E e){ + Objects.requireNonNull(e, "e must not be null"); + this.deque = this.deque.copyOf(this.deque, this.deque.length+1); + this.deque[this.deque.length-1] = e; + } + + public boolean isEmpty(){ + if (this.deque.length==0){ + return true; + } + else{ + return false; + } + } + + public E removeFirst(){ + this.deque = this.deque.copyOfRange(this.deque, 1, this.deque.length); + } + + public E removeLast(){ + this.deque = this.deque.copyOfRange(this.deque, 0, this.deque.length-1); + } + +} diff --git a/DEV3.2/ControleMachine/DEV32/2/SimpleDequeThatsNotCricket.java b/DEV3.2/ControleMachine/DEV32/2/SimpleDequeThatsNotCricket.java new file mode 100644 index 0000000..e0f0744 --- /dev/null +++ b/DEV3.2/ControleMachine/DEV32/2/SimpleDequeThatsNotCricket.java @@ -0,0 +1,52 @@ +import java.util.Objects; +import java.util.LinkedList; +import java.util.Deque; + + +/** + * Implémentation de l'interface MinimalDeque + * + * sert uniquement à tester les tests + * contrairement au sujet de Luc "Huck" Hernandez, fonctionne par délégation à un attribut + * implémentant Deque (ici une LinkedList) + * + * @author Florent Madelaine + * @see Java.util.Deque + */ +public class SimpleDequeThatsNotCricket implements MinimalDeque{ + + /** + * attribut à qui on va déléguer le travail. + */ + private Deque d; + + public SimpleDequeThatsNotCricket(){ + this.d = new LinkedList(); + } + + public void addFirst(E e){ + Objects.requireNonNull(e, "e must not be null"); + this.d.addFirst(e); + } + + public void addLast(E e){ + Objects.requireNonNull(e, "e must not be null"); + this.d.addLast(e); + } + + public boolean isEmpty(){ + return this.d.isEmpty(); + } + + public E removeFirst(){ + return this.d.removeFirst(); + } + + public E removeLast(){ + return this.d.removeLast(); + } + + public String toString(){ + return this.d.toString(); + } +} diff --git a/DEV3.2/ControleMachine/DEV32/2/TestSimpleDeque.java b/DEV3.2/ControleMachine/DEV32/2/TestSimpleDeque.java new file mode 100644 index 0000000..4e3c7f0 --- /dev/null +++ b/DEV3.2/ControleMachine/DEV32/2/TestSimpleDeque.java @@ -0,0 +1,141 @@ +import static org.junit.Assert.assertTrue; // import static : une facilité offerte depuis java5 (pas besoin de mettre le préfixe) +import static org.junit.Assert.assertFalse; // +import static org.junit.Assert.assertSame; // +import org.junit.Test; + + +import java.util.NoSuchElementException; +import java.util.Random; + + +/** + * Une classe pour faire des tests sur la classe SimpleDeque avec JUnit + * On utlise des string comme type paramétré. + */ +public class TestSimpleDeque { + + + /** + * On ne peut pas ajouter avec addFirst l'élément null + * [0.5 point] + */ + @Test + public void addFirstNull(){ + MinimalDeque d = new SimpleDeque(); + + d.addFirst(null); + d.contains(null); + } + + /** + * On ne peut pas ajouter avec addLast l'élément null + * [0.5 point] + */ + @Test + public void addLastNull(){ + + } + + /** + * Un deque sans élément est vide. + * [0.5 point] + */ + @Test + public void addNoneIsEmpty(){ + + } + + /** + * Un deque avec 1 élément n'est pas vide. + * [0.5 point] + */ + @Test + public void addOneIsNotEmpty(){ + + } + + + /** + * Dans un deque vide ajouter devant "ga" "bu" "zo" "meu" devant puis enlever à la fin me redonne les mêmes string (identiques aux précédents) et dans le même ordre. + * [1 point] + */ + @Test + public void pasDeResquilleur(){ + MinimalDeque d = new SimpleDeque(); + String ga = "ga"; + String bu = "bu"; + String zo = "zo"; + String meu = "meu"; + + } + + /** + * Dans un deque vide ajouter "ga" "bu" "zo" "meu" derrière puis enlever au débutr me redonne les mêmes string (identiques aux précédents) et dans le même ordre. + * [1 point] + */ + @Test + public void pasDeResquilleurQuantique(){ + + } + + /** + * On ne peut pas enlever d'élément devant d'un deque vide. + * [1 point] + */ + @Test + public void removeFirstFromEmpty(){ + + } + + /** + * On ne peut pas enlever d'élément derrière d'un deque vide. + * [1 point] + */ + @Test + public void removeLastFromEmpty(){ + + } + + /** + * Dans un deque vide ajouter "ga" puis enlever me redonne le même string que ajouter ou enlever soit devant oui derrière. + * [2 point] + */ + @Test + public void mangerLaBananeParLesDeuxBouts(){ + MinimalDeque d = new SimpleDeque(); + String ga = "ga"; + + } + + + /** + * Invariant de taille + * Lancer un nombre entier aléatoire N compris entre 100 et 1000 (inclus). + * + * Ajouter au hasard, devant ou derrière N éléments tirés au hasard dans {"Ga", "bu", "zo", "meu"}. + * + * Enlever au hasard, devant ou derrière N éléments. + * + * Vérifier finalement que la Deque est vide. + * + * [4 point] + */ + @Test + public void invariantTaille(){ + MinimalDeque d = new SimpleDeque(); + String[] s = {"ga","bu","zo","meu"}; + Random rd = new Random(); + + int N = rd.nextInt(42)+4; + + // rd.nextBoolean()) + + + // s[rd.nextInt(4)]) + + } + + + + +} diff --git a/DEV3.2/ControleMachine/pourchot_dev32.tar.gz b/DEV3.2/ControleMachine/pourchot_dev32.tar.gz new file mode 100644 index 0000000..3303885 Binary files /dev/null and b/DEV3.2/ControleMachine/pourchot_dev32.tar.gz differ diff --git a/DEV3.4/TP6/Main.class b/DEV3.4/TP6/Main.class index 8e34f5e..b204e20 100644 Binary files a/DEV3.4/TP6/Main.class and b/DEV3.4/TP6/Main.class differ diff --git a/DEV3.4/TP6/Main.java b/DEV3.4/TP6/Main.java index a34231a..db8d777 100644 --- a/DEV3.4/TP6/Main.java +++ b/DEV3.4/TP6/Main.java @@ -29,5 +29,7 @@ public class Main{ joueur.recule(); joueur.recule(); joueur.vueToString(); + joueur.avance(); + joueur.vueToString(); } } \ No newline at end of file diff --git a/DEV3.4/TP7/Junit4Exemples.tar.gz b/DEV3.4/TP7/Junit4Exemples.tar.gz new file mode 100644 index 0000000..9ba5217 Binary files /dev/null and b/DEV3.4/TP7/Junit4Exemples.tar.gz differ diff --git a/DEV3.4/TP7/Junit4Exemples/AssertTests.java b/DEV3.4/TP7/Junit4Exemples/AssertTests.java new file mode 100644 index 0000000..44b0c16 --- /dev/null +++ b/DEV3.4/TP7/Junit4Exemples/AssertTests.java @@ -0,0 +1,106 @@ +/** + Il y a en fait pleins d'assertions possibles. + + voici un exemple faisant un petit tour de ce qui est possible que j'ai pris ici. + https://github.com/junit-team/junit4/wiki/Assertions + + NB. hamcrest est un projet maintenant intégré à junit + (c'est un anagrame de matchers) + + */ + +import static org.hamcrest.CoreMatchers.allOf; +import static org.hamcrest.CoreMatchers.anyOf; +import static org.hamcrest.CoreMatchers.both; +import static org.hamcrest.CoreMatchers.containsString; +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.CoreMatchers.everyItem; +import static org.hamcrest.CoreMatchers.hasItems; +import static org.hamcrest.CoreMatchers.not; +import static org.hamcrest.CoreMatchers.sameInstance; +import static org.hamcrest.CoreMatchers.startsWith; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNotSame; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +import java.util.Arrays; + +import org.hamcrest.core.CombinableMatcher; +import org.junit.Test; + +public class AssertTests { + @Test + public void testAssertArrayEquals() { + byte[] expected = "trial".getBytes(); + byte[] actual = "trial".getBytes(); + assertArrayEquals("failure - byte arrays not same", expected, actual); + } + + @Test + public void testAssertEquals() { + assertEquals("failure - strings are not equal", "text", "text"); + } + + @Test + public void testAssertFalse() { + assertFalse("failure - should be false", false); + } + + @Test + public void testAssertNotNull() { + assertNotNull("should not be null", new Object()); + } + + @Test + public void testAssertNotSame() { + assertNotSame("should not be same Object", new Object(), new Object()); + } + + @Test + public void testAssertNull() { + assertNull("should be null", null); + } + + @Test + public void testAssertSame() { + Integer aNumber = Integer.valueOf(768); + assertSame("should be same", aNumber, aNumber); + } + + // JUnit Matchers assertThat + @Test + public void testAssertThatBothContainsString() { + assertThat("albumen", both(containsString("a")).and(containsString("b"))); + } + + @Test + public void testAssertThatHasItems() { + assertThat(Arrays.asList("one", "two", "three"), hasItems("one", "three")); + } + + @Test + public void testAssertThatEveryItemContainsString() { + assertThat(Arrays.asList(new String[] { "fun", "ban", "net" }), everyItem(containsString("n"))); + } + + // Core Hamcrest Matchers with assertThat + @Test + public void testAssertThatHamcrestCoreMatchers() { + assertThat("good", allOf(equalTo("good"), startsWith("good"))); + assertThat("good", not(allOf(equalTo("bad"), equalTo("good")))); + assertThat("good", anyOf(equalTo("bad"), equalTo("good"))); + assertThat(7, not(CombinableMatcher. either(equalTo(3)).or(equalTo(4)))); + assertThat(new Object(), not(sameInstance(new Object()))); + } + + @Test + public void testAssertTrue() { + assertTrue("failure - should be true", true); + } +} diff --git a/DEV3.4/TP7/Junit4Exemples/Calculator.java b/DEV3.4/TP7/Junit4Exemples/Calculator.java new file mode 100644 index 0000000..3f8e4a5 --- /dev/null +++ b/DEV3.4/TP7/Junit4Exemples/Calculator.java @@ -0,0 +1,30 @@ + +/** + Calculator est une classe offrant une seule méthode qui évalue une somme, donnée sous la forme d'une chaîne de caractère listant des opérandes séparées par des + + +*/ + +public class Calculator { + + /** + somme les opérandes passées sous forme d'une chaîne de caractères et retourne le résultat sous forme d'entier. + @param expression : chaîne de caractères ("nombres" séparés par des + sans espaces), par exemple "42+3" ou encore "-42+42" (le moins unaire est autorisé). + ici nombre est à comprendre au sens de parseInt(java.lang.String) + @throws NumberFormatException : si l'expression n'est pas dans ce format (par exemple "x+2" ou " 1 +2" -- il y a des espaces -- ou encore "9999999990"). + */ + public int evaluate(String expression) { + int sum = 0; + for (String summand: expression.split("\\+")) + sum += Integer.valueOf(summand); + return sum; + } + + /** + Pour appeller cette super méthode depuis la ligne de commande (on ne regarde que le premier argument, les autres sont ignorés). + + */ + public static void main(String[] args) { + Calculator calculator = new Calculator(); + System.out.println(calculator.evaluate(args[0])); + } +} diff --git a/DEV3.4/TP7/Junit4Exemples/CalculatorTest0.java b/DEV3.4/TP7/Junit4Exemples/CalculatorTest0.java new file mode 100644 index 0000000..38fc2c3 --- /dev/null +++ b/DEV3.4/TP7/Junit4Exemples/CalculatorTest0.java @@ -0,0 +1,30 @@ +import static org.junit.Assert.assertEquals; // import static : une facilité offerte par java5 +import org.junit.Test; + +/** + CalculatorTest0 est un premier exemple de test pour la classe Calculator utilisant junit4 + Assert, ou comment vérifier qu'une méthode donne un résultat correct? + + Remarque en passant, pour tester en ligne de commande (une fois les classes compilées), il faut faire + $java org.junit.runner.JUnitCore CalculatorTest0 + + Remarque, comme expliqué dans la doc de org.junit.runner.JUnitCore +JUnitCore is a *facade* for running tests. It supports running JUnit 4 tests, JUnit 3.8.x tests, and mixtures. To run tests from the command line, run java org.junit.runner.JUnitCore TestClass1 TestClass2 + + Oh le joli design pattern. C'est cadeau. + */ + +public class CalculatorTest0 { + + + // un test pour Junit4 c'est une méthode avec l'annotation suivante devant la méthode. + @Test + public void evaluatesGoodExpression() { + Calculator calculator = new Calculator(); + int sum = calculator.evaluate("1+2+3"); + // on peut stipuler que des choses sont normalement égales (il faut charger de manière statique les Assert si on veut éviter d'avoir à écrire de quelle classe on parle) + assertEquals(6, sum); + } + + +} diff --git a/DEV3.4/TP7/Junit4Exemples/CalculatorTest1.java b/DEV3.4/TP7/Junit4Exemples/CalculatorTest1.java new file mode 100644 index 0000000..f8bed1d --- /dev/null +++ b/DEV3.4/TP7/Junit4Exemples/CalculatorTest1.java @@ -0,0 +1,18 @@ +import static org.junit.Assert.assertEquals; +import org.junit.Test; + +/** + CalculatorTest1 est un exemple de test pour la classe Calculator utilisant junit4. + Comment vérifier qu'on lance bien une exception? + */ + +public class CalculatorTest1 { + + + // un test pour Junit4 qui cherche à vérifier qu'il y a bien une exception + @Test(expected = NumberFormatException.class) + public void doesNotEvaluateBadExpression() { + Calculator calculator = new Calculator(); + int sum = calculator.evaluate("1 +2+3");//notez l'espace qui va génèrez une exception + } +} diff --git a/DEV3.4/TP7/Junit4Exemples/CalculatorTest2.java b/DEV3.4/TP7/Junit4Exemples/CalculatorTest2.java new file mode 100644 index 0000000..25b6590 --- /dev/null +++ b/DEV3.4/TP7/Junit4Exemples/CalculatorTest2.java @@ -0,0 +1,48 @@ +import static org.junit.Assert.assertEquals; +import org.junit.Test; + +import org.junit.BeforeClass; // ne pas oublie de charger le fait qu'on veut l'annotation @BeforeClass +import org.junit.AfterClass; + +/** + + CalculatorTest2 est un exemple de test pour la classe Calculator utilisant junit4 + Il réunit en fait les deux tests des 2 classes précédentes dans une seule classe. + + Typiquement on a en effet tous les tests simples portant sur une classe "métier" regroupée dans une classe de test correspondante. + Avec les annotations, on peut factoriser des choses concernant tous ces tests. + + */ + +public class CalculatorTest2 { + static Calculator calculator; + + // On peut si on le souhaite faire un traitement avant tous les tests (typiquement on fait quelque chose de cher comme se connecter à une base de données, ici j'économise une instance de Calculator (on s'en moque un peu pour être honnête). + @BeforeClass + public static void setUp() { + System.out.println("Avant tous les tests"); + calculator = new Calculator(); + } + + @Test + public void evaluatesGoodExpression() { + System.out.println("Test evaluation bonne expression"); + int sum = calculator.evaluate("1+2+3"); + assertEquals(6, sum); + } + + + @Test(expected = NumberFormatException.class) + public void doesNotEvaluateBadExpression() { + System.out.println("Test evaluation mauvaise expression"); + int sum = calculator.evaluate("1 +2+3"); + } + + // On peut si on le souhaite faire un traitement après tous les tests (typiquement on fait quelque chose de cher comme se connecter à une base de données, ici j'économise une instance de Calculator (on s'en moque un peu pour être honnête). + @AfterClass + public static void tearDown() { + System.out.println("Après tous les Test"); + calculator = null; + } + +} diff --git a/DEV3.4/TP7/Junit4Exemples/CalculatorTest3.java b/DEV3.4/TP7/Junit4Exemples/CalculatorTest3.java new file mode 100644 index 0000000..64caf19 --- /dev/null +++ b/DEV3.4/TP7/Junit4Exemples/CalculatorTest3.java @@ -0,0 +1,20 @@ +import static org.junit.Assert.assertEquals; +import org.junit.Test; + +/** + CalculatorTest3 est un exemple de test pour la classe Calculator utilisant junit4 qui est volontairement non satisfait + + */ + +public class CalculatorTest3 { + + + @Test + public void evaluatesGoodExpression() throws Exception{ + Calculator calculator = new Calculator(); + int sum = calculator.evaluate("1+2+3"); + assertEquals(42, sum); + } + + +} diff --git a/DEV3.4/TP7/Junit4Exemples/Readme.txt b/DEV3.4/TP7/Junit4Exemples/Readme.txt new file mode 100644 index 0000000..993782c --- /dev/null +++ b/DEV3.4/TP7/Junit4Exemples/Readme.txt @@ -0,0 +1,43 @@ +Les fichiers et ce qu'ils illustrent + +Calculator.java le fichier contenant la classe qu'on va prétendre couloir tester. + +CalculatorTest0.java mon premier test avec Junit4 et assert +CalculatorTest1.java mon second test avec Junit4 pour des exceptions +CalculatorTest2.java les deux précédents +CalculatorTest3.java un test volontairement non satisfait + +Jusqu'ici pour exécuter un test, on compile tous les fichiers (une fois le classpath correct) puis on fait : + +$java org.junit.runner.JUnitCore CalculatorTest0 + +voir plusieurs classes de tests suite à suite, en faisant : + +$java org.junit.runner.JUnitCore CalculatorTest0 CalculatorTest1 + +Des choses un peu plus avancées + +RunForestRun.java un exemple de runner (alternative à la ligne de commande qui fait la même chose en java). +TestParam.java mon premier test avancé permettant d'exécuter un test simple sur une liste de paramètres. +TestSuite.java comment combiner plusieurs tests (par exemple si on veut tester plusieurs classes en même temps). +AssertTests.java Squelette de toutes les variantes d'assertion proposées par Junit4 + +=== + +Pour pouvoir utiliser ces tests à bon escients, il faut : +_ avoir installé Junit4 (c'est un jar) +_ faire ce qu'il faut au CLASSPATH pour que Junit4 soit dedans. + +Par exemple sur ma machine, j'ai plusieurs versions de junit: + +$ ls -l /usr/share/java/junit* +-rw-r--r-- 1 root root 108762 mai 18 2012 /usr/share/java/junit-3.8.2.jar +-rw-r--r-- 1 root root 313072 mars 8 2016 /usr/share/java/junit4-4.12.jar +lrwxrwxrwx 1 root root 15 mars 8 2016 /usr/share/java/junit4.jar -> junit4-4.12.jar +lrwxrwxrwx 1 root root 15 mai 18 2012 /usr/share/java/junit.jar -> junit-3.8.2.jar + +Du coup, j'ai fait en sorte que mon CLASSPATH contienne /usr/share/java/junit4.jar + +$ echo $CLASSPATH +.:/usr/lib/jvm/java-8-openjdk-amd64/lib:/usr/share/java/junit4.jar + diff --git a/DEV3.4/TP7/Junit4Exemples/RunForestRun.java b/DEV3.4/TP7/Junit4Exemples/RunForestRun.java new file mode 100644 index 0000000..8626247 --- /dev/null +++ b/DEV3.4/TP7/Junit4Exemples/RunForestRun.java @@ -0,0 +1,24 @@ +/** + + Alternative à la ligne de commande, on peut appeller le runner depuis java avec org.junit.runner.JUnitCore.runClasses +qui retourne un objet de type Result qui modélise les résultats des tests. + +En particulier, on peut accéder à la liste des échecs -- un échec eest un objet Failure -- avec getFailures + + */ + + +import org.junit.runner.JUnitCore; +import org.junit.runner.Result; +import org.junit.runner.notification.Failure; + +public class RunForestRun { + + public static void main(String[] args) { + final Result result = org.junit.runner.JUnitCore.runClasses(CalculatorTest0.class,CalculatorTest1.class,CalculatorTest3.class); + for (final Failure failure : result.getFailures()) { + System.out.println(failure.toString()); // affiche détail sur chaque échec + } + System.out.println(result.wasSuccessful()); // affiche true ssi aucune erreurs + } +} diff --git a/DEV3.4/TP7/Junit4Exemples/TestParam.java b/DEV3.4/TP7/Junit4Exemples/TestParam.java new file mode 100644 index 0000000..2416862 --- /dev/null +++ b/DEV3.4/TP7/Junit4Exemples/TestParam.java @@ -0,0 +1,47 @@ +/** + + Example d'utilisation d'un runner spécial : Parameterized. + + Ce runner permet de facilement itérer des tests similaires sur plusieurs choix de valeurs. + + + */ +import static org.junit.Assert.assertEquals; + +import java.util.Arrays; +import java.util.Collection; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameters; + + +// l'annotation @RunWith propre aux runners +@RunWith(Parameterized.class) +public class TestParam { + + // l'annotation @Parameters pour aller chercher les paramètres des tests (on itère sur des tuples d'objet) + @Parameters(name = "{index}: {0} = {2}") + public static Iterable data() { + return Arrays.asList(new Object[][] { { "1+2+3", 6 }, { "40+2", 42 }, + { "001+41", 42 }, { "0000", 0 }, { "999+-999", 0 } }); + } + + // les attributs qui correspondent aux éléments de nos tuples + private String expression; + private int res; + + // le constructeur + public TestParam(String expression, int res) { + this.expression = expression; + this.res = res; + } + + // le test qui va manger les paramètres qu'on vient de définir + @Test + public void evaluatesGoodExpressions() { + Calculator calculator=new Calculator(); + assertEquals(res, calculator.evaluate(expression)); + } +} diff --git a/DEV3.4/TP7/Junit4Exemples/TestSuite.java b/DEV3.4/TP7/Junit4Exemples/TestSuite.java new file mode 100644 index 0000000..d342de3 --- /dev/null +++ b/DEV3.4/TP7/Junit4Exemples/TestSuite.java @@ -0,0 +1,26 @@ +/** + Un runner spécial qui sert à créer une collection de tests. + Typiquement, on peut avoir une classe de tests unitaires pour chaque classe métier et une "suite de tests" qui va appeller tous les tests de classes ayant un lien (par exemple dans le même paquet). + + Ceci est de nouveau un test, qu'on peut exécuter en faisant par exemple dans une console + java org.junit.runner.JUnitCore TestSuite + + */ + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; + +// @RunWith permet d'indiquer le runner +@RunWith(Suite.class) + +//les tests à faire et dans quel ordre. +@Suite.SuiteClasses({ + CalculatorTest0.class, + CalculatorTest1.class, + CalculatorTest3.class +}) + +public class TestSuite { + // La classe est vide en fait + // C'est juste un conteneur pour les annotations du dessus, utilisés par Junit4 +} diff --git a/DEV4.4/TP0/base_64.c b/DEV4.4/TP0/base_64.c new file mode 100644 index 0000000..a8848ce --- /dev/null +++ b/DEV4.4/TP0/base_64.c @@ -0,0 +1,88 @@ +#include +#include +#include +#include +#include + + +static const char base64_table[] = { + 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', + 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', + 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', + 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', + 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', + 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', + 'w', 'x', 'y', 'z', '0', '1', '2', '3', + '4', '5', '6', '7', '8', '9', '+', '/' +}; + +void base64_encode_file(char * file, char * file_encoded) +{ + int i = 0; + int fdin, fdout ; + unsigned char buffer[3]; // octets a encoder + unsigned char tmp[4]; // valeurs des 4 groupes de 6 bits + char buffer_encoded[4]; // octets encodes + ssize_t nb_read; + + + + fdin = open(file,O_RDONLY); + fdout = open(file_encoded,O_WRONLY|O_TRUNC|O_CREAT,0644); + + assert(fdin >= 0); + assert(fdout >= 0); + + while(1){ + nb_read = read(fdin,buffer,3); + + if (nb_read < 3) + break; + // TODO + // calculer la valeur des 4 groupes de 6 bits de buffer + + tmp[0] = buffer[0] >> 2; + tmp[1] = buffer[0] << 4 + buffer[1] << 4; + tmp[2] = buffer[1] << 2 + buffer[2] << 6; + tmp[3] = buffer[2]; + + for (i = 0; i < 4 ;i++) + buffer_encoded[i] = base64_table[tmp[i]]; + + write(fdout,buffer_encoded,4); + + } + + // TODO + /* il reste quelque chose ? */ + + if ( nb_read != 0){ + for( i = nb_read; i < 3; i++) + buffer[i] = 0; + + tmp[0] = 0; + tmp[1] = 0; + tmp[2] = 0; + tmp[3] = 0; + + for (i = 0; i < nb_read + 1 ;i++) + buffer_encoded[i] = base64_table[tmp[i]]; + + for (i = nb_read + 1; i < 4 ;i++) + buffer_encoded[i] = '='; + + + write(fdout,buffer_encoded,4); + } + + close(fdin); + close(fdout); +} + +int main(int argc, char *argv[]) +{ + assert(argc >= 3); + base64_encode_file(argv[1],argv[2]); + return 0; +} + diff --git a/DEV4.4/TP1/Ex1/file.crypt b/DEV4.4/TP1/Ex1/file.crypt new file mode 100644 index 0000000..1f1e6c2 Binary files /dev/null and b/DEV4.4/TP1/Ex1/file.crypt differ diff --git a/DEV4.4/TP1/Ex1/lfsr.c b/DEV4.4/TP1/Ex1/lfsr.c new file mode 100644 index 0000000..0398216 --- /dev/null +++ b/DEV4.4/TP1/Ex1/lfsr.c @@ -0,0 +1,47 @@ +#include +#include +#include +#include +#include + +#define MASK_BIT_7 0x80 +#define MASK_BIT_6 0x40 +#define MASK_BIT_5 0x20 +#define MASK_BIT_4 0x10 +#define MASK_BIT_3 0x08 +#define MASK_BIT_2 0x04 +#define MASK_BIT_1 0x02 +#define MASK_BIT_0 0x01 + + +unsigned char next(unsigned char lfsr) +{ + lfsr = (lfsr << 1); + if(__builtin_parity(lfsr)==0){ + lfsr ^= 1 << 0; + } + return lfsr; + +} + +int main(int argc, char *argv[]) +{ + int fd_in,fd_out; + unsigned char w,buf;; + + + assert(argc >= 4); + fd_in = open(argv[1],O_RDONLY); + fd_out = open(argv[2],O_WRONLY|O_TRUNC|O_CREAT,0600); + w = (unsigned char)strtol(argv[3],NULL,0); + + while(1){ + ssize_t nb = read(fd_in,&buf,1); + if (nb <=0) + break; + buf ^= w; + write(fd_out,&buf,1); + w=next(w); + } + return 0; +} diff --git a/DEV4.4/TP1/Ex1/text.txt b/DEV4.4/TP1/Ex1/text.txt new file mode 100644 index 0000000..3e41b1d --- /dev/null +++ b/DEV4.4/TP1/Ex1/text.txt @@ -0,0 +1 @@ +Bonjour je m'appelle Jean François Fion. \ No newline at end of file diff --git a/DEV4.4/TP1/Ex1/textencode.crypt b/DEV4.4/TP1/Ex1/textencode.crypt new file mode 100644 index 0000000..85a708f --- /dev/null +++ b/DEV4.4/TP1/Ex1/textencode.crypt @@ -0,0 +1 @@ + W*P]#XZoO*t&< \ No newline at end of file