diff --git a/DEV/DEV2.3/TP02_JUnit/Largest.java~ b/DEV/DEV2.3/TP02_JUnit/Largest.java~ deleted file mode 100644 index e69de29..0000000 diff --git a/DEV/DEV2.3/TP02_JUnit/ex1/AssertTests.class b/DEV/DEV2.3/TP02_JUnit/ex1/AssertTests.class deleted file mode 100644 index d1c8da2..0000000 Binary files a/DEV/DEV2.3/TP02_JUnit/ex1/AssertTests.class and /dev/null differ diff --git a/DEV/DEV2.3/TP02_JUnit/ex1/AssertTests.java~ b/DEV/DEV2.3/TP02_JUnit/ex1/AssertTests.java~ deleted file mode 100644 index 44b0c16..0000000 --- a/DEV/DEV2.3/TP02_JUnit/ex1/AssertTests.java~ +++ /dev/null @@ -1,106 +0,0 @@ -/** - 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/DEV/DEV2.3/TP02_JUnit/ex1/Calculator.class b/DEV/DEV2.3/TP02_JUnit/ex1/Calculator.class deleted file mode 100644 index 1cda9de..0000000 Binary files a/DEV/DEV2.3/TP02_JUnit/ex1/Calculator.class and /dev/null differ diff --git a/DEV/DEV2.3/TP02_JUnit/ex1/Calculator.java~ b/DEV/DEV2.3/TP02_JUnit/ex1/Calculator.java~ deleted file mode 100644 index 3f8e4a5..0000000 --- a/DEV/DEV2.3/TP02_JUnit/ex1/Calculator.java~ +++ /dev/null @@ -1,30 +0,0 @@ - -/** - 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/DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest0.class b/DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest0.class deleted file mode 100644 index f8951d3..0000000 Binary files a/DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest0.class and /dev/null differ diff --git a/DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest1.class b/DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest1.class deleted file mode 100644 index fee7689..0000000 Binary files a/DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest1.class and /dev/null differ diff --git a/DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest1.java~ b/DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest1.java~ deleted file mode 100644 index f8bed1d..0000000 --- a/DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest1.java~ +++ /dev/null @@ -1,18 +0,0 @@ -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/DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest2.class b/DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest2.class deleted file mode 100644 index 10b5656..0000000 Binary files a/DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest2.class and /dev/null differ diff --git a/DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest3.class b/DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest3.class deleted file mode 100644 index f090864..0000000 Binary files a/DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest3.class and /dev/null differ diff --git a/DEV/DEV2.3/TP02_JUnit/ex2/Largest.class b/DEV/DEV2.3/TP02_JUnit/ex2/Largest.class index 70f873d..613b3b1 100644 Binary files a/DEV/DEV2.3/TP02_JUnit/ex2/Largest.class and b/DEV/DEV2.3/TP02_JUnit/ex2/Largest.class differ diff --git a/DEV/DEV2.3/TP02_JUnit/ex2/Largest.java~ b/DEV/DEV2.3/TP02_JUnit/ex2/Largest.java~ deleted file mode 100644 index 0f0bf68..0000000 --- a/DEV/DEV2.3/TP02_JUnit/ex2/Largest.java~ +++ /dev/null @@ -1,18 +0,0 @@ -public class Largest { - - /** - * Return the largest element in a list. - * - * @param list A list of integers - * @return The largest number in the given list - */ - public static int largest(int[] list) { - int index, max=Integer.MIN_VALUE; - for (index = 0; index <= list.length-1; index++) { - if (list[index] > max) { - max = list[index]; - } - } - return max; - } -} diff --git a/DEV/DEV2.3/TP02_JUnit/ex2/TestLargest.class b/DEV/DEV2.3/TP02_JUnit/ex2/TestLargest.class index 0bb853a..609e78c 100644 Binary files a/DEV/DEV2.3/TP02_JUnit/ex2/TestLargest.class and b/DEV/DEV2.3/TP02_JUnit/ex2/TestLargest.class differ diff --git a/DEV/DEV2.3/TP02_JUnit/ex2/TestLargest.java~ b/DEV/DEV2.3/TP02_JUnit/ex2/TestLargest.java~ deleted file mode 100644 index 3d99d70..0000000 --- a/DEV/DEV2.3/TP02_JUnit/ex2/TestLargest.java~ +++ /dev/null @@ -1,10 +0,0 @@ -import static org.junit.Assert.assertEquals; -import org.junit.Test; - -public class TestLargest { - - @Test - public void testSimple() { - assertEquals(12, Largest.largest(new int[] {9,8,7,12})); - } -} diff --git a/DEV/DEV2.3/cm1/Reponses.txt b/DEV/DEV2.3/cm1/Reponses.txt deleted file mode 100644 index 9b41fa5..0000000 --- a/DEV/DEV2.3/cm1/Reponses.txt +++ /dev/null @@ -1,38 +0,0 @@ -// Il faut compléter les questions par vos réponses ci-dessous. - -======================================================================================== -Question 1. -Quelle est la sanction disciplinaire encourrue en cas de triche à un TP noté à l'IUT? - -Votre réponse : sans doute un 0/20 - - - - -======================================================================================== -Question 2. -Quelles sont la ou les commandes nécessaires pour lancer les tests permettant de debuguer pour la première partie du TP? - -Votre réponse : -CLASSPATH=".:/usr/share/java/junit.jar:/usr/share/java/hamcrest-core.jar" -javac -cp $CLASSPATH -java -cp $CLASSPATH org.junit.runner.JUnitCore - - - -======================================================================================== -Question 3. -Comment puis-je tester si une méthode retourne une exception avec JUnit? - -Votre réponse :en mettant des parenthèse derrière le @Test, avec l'erreur que l'on souhaite que la méthode retourne. voici un exemple plus parlant: -@Test(expected = NullPointerException.class) - - - - - - - - - -======================================================================================== diff --git a/DEV/DEV2.3/cm1/TestsACompleterDirection.java b/DEV/DEV2.3/cm1/TestsACompleterDirection.java deleted file mode 100644 index 9c98790..0000000 --- a/DEV/DEV2.3/cm1/TestsACompleterDirection.java +++ /dev/null @@ -1,75 +0,0 @@ -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.assertEquals; // -import org.junit.Test; - -import java.lang.StringBuilder; - - - -/** - * Une classe pour faire des tests sur la classe MaMemoire avec JUnit - */ -public class TestsACompleterDirection { - - - /** - * Test nord x vaut 0 - */ - @Test - public void Nordx(){ - Direction d = Direction.NORD; - assertEquals(0,d.getDecalageX()); - - } - - /** - * Test nord y vaut -1 - */ - @Test - public void Nordy(){ - Direction d = Direction.NORD; - assertEquals(-1,d.getDecalageY()); //on constate que dans le fichier Direction.java, les - } - - /** - * Test que reset retourne une NullPointerException - */ - @Test(expected = NullPointerException.class) - public void ResetNPE(){ - Direction.reset(); - } - - - /** - * Test que l'on peut faire 64 fois un huitième de tour dans le sens trigonométrique et être au même endroit quand on part du Sud Est - */ - @Test - public void whenIGetOlder(){ - Direction d1 = Direction.SE; - Direction d2 = Direction.SE; - for (int i=0; i<64; i++){ - d2 = d2.huitDeTour(); - } - assertEquals(d1,d2); - } - - - /** - * Test que l'on peut faire 65 fois un huitième detour dans le sens antitrigonométrique et être au même endroit que si on faisait un anti huitième de tour quand on part du Sud Est - */ - @Test - public void losingMyHair(){ - Direction d1 = Direction.SE; - Direction d2 = Direction.SE; - for (int i=0; i<65; i++){ - d2 = d2.huitDeTourAnti(); - } - assertEquals(d1.huitDeTourAnti(),d2); - } - - - - - -} diff --git a/DEV/DEV2.3/cm3/Direction.java~ b/DEV/DEV2.3/cm3/Direction.java~ deleted file mode 100644 index f0bb41b..0000000 --- a/DEV/DEV2.3/cm3/Direction.java~ +++ /dev/null @@ -1,226 +0,0 @@ -import java.util.Objects; - -/** - * La classe Direction, initialement utilisée pour signifier une orientation possible - * parmi les quatre points cardinaux, a été transformée pour permettre de fabriquer une rose des vents à 8 directions. - * - * (y) - * - * -1 NO N NE - * - * 0 O E - * - * 1 SO S SE - * - * -1 0 1 (x) - * - * @version 1.2 - * @author Luc Hernandez, Florent Madelaine. - */ -public class Direction { - - /** - * Constante pointant vers le nord (c'est à dire vers le haut de l'écran). - */ - public static final Direction NORD = new Direction(+0, -1);///BUGFIX remplacé (0, 1) par (0, -1) - - /** - * Constante pointant vers le Nord Ouest (c'est à dire la diagonale entre le haut et la gauche de l'écran). - */ - public static final Direction NO = new Direction(-1, -1); - - /** - * Constante pointant vers l'ouest (c'est à dire vers la gauche de l'écran). - */ - public static final Direction OUEST = new Direction(-1, +0); - - /** - * Constante pointant vers le Sud Ouest (c'est à dire la diagonale entre le bas et la gauche de l'écran). - */ - public static final Direction SO = new Direction(-1, +1); - - /** - * Constante pointant vers le sud (c'est à dire vers le bas de l'écran). - */ - public static final Direction SUD = new Direction(+0, +1); - - /** - * Constante pointant vers le Sud Est (c'est à dire la diagonale vers le bas et la droite de l'écran). - */ - public static final Direction SE = new Direction(+1, +1); - - /** - * Constante pointant vers l'est (c'est à dire vers la droite de l'écran). - */ - public static final Direction EST = new Direction(+1, +0); - - /** - * Constante pointant vers le Nord Est (c'est à dire la diagonale vers le haut et la droite de l'écran). - */ - public static final Direction NE = new Direction(+1, -1); - - - /** - * Composante horizontale de la direction (-1, 0 ou 1). - */ - private int decalageX; - - /** - * Composante verticale de la direction (-1, 0 ou 1). - */ - private int decalageY; - - /** - * Constructeur uniquement destiné à la création des constantes publiques. - * - * @param x l'abcisse (-1, 0 ou 1) - * @param y l'ordonnée (-1, 0 ou 1) - */ - private Direction(int x, int y) { - this.decalageX = x; //BUGFIX y par x - this.decalageY = y; //BUGFIX x par y - } - - /** - * Renvoie la composante horizontale de la direction. - * - * @return la composante horizontale de la direction (-1, 0 ou 1) - */ - public int getDecalageX() { - return this.decalageX; - } - - /** - * Renvoie la composante verticale de la direction. - * - * @return la composante verticale de la direction (-1, 0 ou 1) - */ - public int getDecalageY() { - return this.decalageY; - } - - - private static Direction[] DirectionsInTrigOrder = { Direction.NORD, Direction.NE, Direction.EST, Direction.SE, Direction.SUD, Direction.SO, Direction.OUEST, Direction.NO}; - - /** - * Renvoie la direction produite par un décalage de un huitième de tour dans le sens horaire. - * - * @return la nouvelle direction - */ - public Direction huitDeTour() { - for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) { //BUGFIX i < this.DirectionsInTrigOrder.length - 1 par i< i < this.DirectionsInTrigOrder.length - if (this == this.DirectionsInTrigOrder[i]) - return this.DirectionsInTrigOrder[(i+1) % this.DirectionsInTrigOrder.length]; //BUGFIX i+1%this.DirectionsInTrigOrder.length par (i+1)%this.DirectionsInTrigOrder.length - } - return null; - } - - /** - * Renvoie la direction produite par un décalage d'un huitième de tour dans le sens anti-horaire. - * - * @return la nouvelle direction - */ - public Direction huitDeTourAnti() { - for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) { //BUGFIX i+=2 par ++ - if (this == this.DirectionsInTrigOrder[i]){ //BUGFIX {} par {return ...} - return this.DirectionsInTrigOrder[((i+8-1) % this.DirectionsInTrigOrder.length)]; - } - - } - return null; - } - - /** - * Renvoie la direction produite par un quart de tour dans le sens horaire. - * - * @return la nouvelle direction - */ - public Direction quartDeTour() { - for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) { //BUGFIX i=1 par i=0 - if (this == this.DirectionsInTrigOrder[i]) - return this.DirectionsInTrigOrder[(i+2) % this.DirectionsInTrigOrder.length]; - - } - return null; - } - - /** - * Renvoie la direction produite par un quart de tour dans le sens anti-horaire. - * - * @return la nouvelle direction - */ - public Direction quartDeTourAnti() { - for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) { - if (this == this.DirectionsInTrigOrder[i])// de i-1 à i - return this.DirectionsInTrigOrder[(i+6)%this.DirectionsInTrigOrder.length]; //BUGFIX remplacé i+8-2 par (i+6)%this.DirectionsInTrigOrder.length - - } - return null; - } - - - /** - * Renvoie la direction produite par un demi tour. - * - * @return la nouvelle direction - */ - public Direction demiTour() { - for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) { - if (this == this.DirectionsInTrigOrder[i]){ - Direction d = this.DirectionsInTrigOrder[(i+4)% this.DirectionsInTrigOrder.length]; - return d; //BUGFIX remplacé d.DirectionsInTrigOrder[(i+5)% this.DirectionsInTrigOrder.length] par d - } - - } - return null; - } - - - - - // /** - // * Renvoie la direction produite par un quart de tour dans le sens horaire. - // * - // * @return la nouvelle direction - // */ - // public Direction quartDeTour() { - // if (this == Direction.NORD) - // return Direction.EST; - // else if (this == Direction.EST) - // return Direction.SUD; - // else if (this == Direction.SUD) - // return Direction.OUEST; - // else // if (this == Direction.OUEST) - // return Direction.NORD; - // } - - // /** - // * Renvoie la direction produite par un quart de tour dans le sens anti-horaire. - // * - // * @return la nouvelle direction - // */ - // public Direction quartDeTourAnti() { - // if (this == Direction.NORD) - // return Direction.OUEST; - // else if (this == Direction.EST) - // return Direction.NORD; - // else if (this == Direction.SUD) - // return Direction.EST; - // else // if (this == Direction.OUEST) - // return Direction.SUD; - // } - - - public String toString(){ - return "(x: "+ this.decalageX + " ," + "y:"+ this.decalageY + ")"; - } - - - /** - * Méthode qui ne sert qu'à faire un exemple de méthode qui va renvoyer une exeption - */ - public static void reset(){ - Objects.requireNonNull(null, "On ne devrait pas faire comme ça"); - } - -} diff --git a/DEV/DEV2.3/cm3/TestsACompleterDirection.java b/DEV/DEV2.3/cm3/TestsACompleterDirection.java index 9c98790..bf8a9db 100644 --- a/DEV/DEV2.3/cm3/TestsACompleterDirection.java +++ b/DEV/DEV2.3/cm3/TestsACompleterDirection.java @@ -68,6 +68,12 @@ public class TestsACompleterDirection { assertEquals(d1.huitDeTourAnti(),d2); } + @Test + public void test1(){ + boolean var = true; + assert(var); + } + diff --git a/DEV/DEV2.3/controle_original/Direction.class b/DEV/DEV2.3/controle_original/Direction.class new file mode 100644 index 0000000..e61e070 Binary files /dev/null and b/DEV/DEV2.3/controle_original/Direction.class differ diff --git a/DEV/DEV2.3/cm1/Direction.java b/DEV/DEV2.3/controle_original/Direction.java similarity index 81% rename from DEV/DEV2.3/cm1/Direction.java rename to DEV/DEV2.3/controle_original/Direction.java index f0bb41b..d0f702f 100644 --- a/DEV/DEV2.3/cm1/Direction.java +++ b/DEV/DEV2.3/controle_original/Direction.java @@ -22,7 +22,7 @@ public class Direction { /** * Constante pointant vers le nord (c'est à dire vers le haut de l'écran). */ - public static final Direction NORD = new Direction(+0, -1);///BUGFIX remplacé (0, 1) par (0, -1) + public static final Direction NORD = new Direction(+0, 1); /** * Constante pointant vers le Nord Ouest (c'est à dire la diagonale entre le haut et la gauche de l'écran). @@ -77,8 +77,8 @@ public class Direction { * @param y l'ordonnée (-1, 0 ou 1) */ private Direction(int x, int y) { - this.decalageX = x; //BUGFIX y par x - this.decalageY = y; //BUGFIX x par y + this.decalageX = y; + this.decalageY = x; } /** @@ -107,10 +107,10 @@ public class Direction { * * @return la nouvelle direction */ - public Direction huitDeTour() { - for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) { //BUGFIX i < this.DirectionsInTrigOrder.length - 1 par i< i < this.DirectionsInTrigOrder.length + public Direction huitDeTour() { + for (int i = 0; i < this.DirectionsInTrigOrder.length -1; i++) { if (this == this.DirectionsInTrigOrder[i]) - return this.DirectionsInTrigOrder[(i+1) % this.DirectionsInTrigOrder.length]; //BUGFIX i+1%this.DirectionsInTrigOrder.length par (i+1)%this.DirectionsInTrigOrder.length + return this.DirectionsInTrigOrder[i+1 % this.DirectionsInTrigOrder.length]; } return null; } @@ -121,10 +121,9 @@ public class Direction { * @return la nouvelle direction */ public Direction huitDeTourAnti() { - for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) { //BUGFIX i+=2 par ++ - if (this == this.DirectionsInTrigOrder[i]){ //BUGFIX {} par {return ...} - return this.DirectionsInTrigOrder[((i+8-1) % this.DirectionsInTrigOrder.length)]; - } + for (int i = 0; i < this.DirectionsInTrigOrder.length; i+=2) { + if (this == this.DirectionsInTrigOrder[i]){} + return this.DirectionsInTrigOrder[((i+8-1) % this.DirectionsInTrigOrder.length)]; } return null; @@ -136,7 +135,7 @@ public class Direction { * @return la nouvelle direction */ public Direction quartDeTour() { - for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) { //BUGFIX i=1 par i=0 + for (int i = 1; i < this.DirectionsInTrigOrder.length; i++) { if (this == this.DirectionsInTrigOrder[i]) return this.DirectionsInTrigOrder[(i+2) % this.DirectionsInTrigOrder.length]; @@ -151,8 +150,8 @@ public class Direction { */ public Direction quartDeTourAnti() { for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) { - if (this == this.DirectionsInTrigOrder[i])// de i-1 à i - return this.DirectionsInTrigOrder[(i+6)%this.DirectionsInTrigOrder.length]; //BUGFIX remplacé i+8-2 par (i+6)%this.DirectionsInTrigOrder.length + if (this == this.DirectionsInTrigOrder[i-1]) + return this.DirectionsInTrigOrder[(i+8-2)]; } return null; @@ -168,7 +167,7 @@ public class Direction { for (int i = 0; i < this.DirectionsInTrigOrder.length; i++) { if (this == this.DirectionsInTrigOrder[i]){ Direction d = this.DirectionsInTrigOrder[(i+4)% this.DirectionsInTrigOrder.length]; - return d; //BUGFIX remplacé d.DirectionsInTrigOrder[(i+5)% this.DirectionsInTrigOrder.length] par d + return d.DirectionsInTrigOrder[(i+5)% this.DirectionsInTrigOrder.length]; } } diff --git a/DEV/DEV2.3/controle_original/Exemple.java b/DEV/DEV2.3/controle_original/Exemple.java new file mode 100644 index 0000000..bf070c4 --- /dev/null +++ b/DEV/DEV2.3/controle_original/Exemple.java @@ -0,0 +1,38 @@ +/** + * Mise en oeuvre de la classe Direction, quit permet de manipuler une direction dans la rose des vents à 8 directions. + * + * (y) + * + * -1 NO N NE + * + * 0 O E + * + * 1 SO S SE + * + * -1 0 1 (x) + * + * @version 1.2 + * @author Florent Madelaine. + */ + +public class Exemple{ + + public static void main(String[] args) { + Direction d = Direction.NORD; + System.out.println(d.toString()); + d = d.demiTour(); + System.out.println(d.toString()); + d = d.demiTour(); + System.out.println(d.toString()); + int i = 0; + System.out.println(i); + int j = i+8-1; + System.out.println(j); + int k = j % 8; + System.out.println(k); + int l = i-1; + System.out.println(l); + int m = l % 8; + System.out.println(m); + } +} diff --git a/DEV/DEV2.3/controle_original/README.md b/DEV/DEV2.3/controle_original/README.md new file mode 100644 index 0000000..ae1a6ce --- /dev/null +++ b/DEV/DEV2.3/controle_original/README.md @@ -0,0 +1,53 @@ +# TP noté sur les tests + +## Fichiers mis à disposition +Pour ce TP noté sur les tests, vous disposez des fichiers suivants + ++ README.md ce fichier, qui vous indique ce qu'il faut faire. ++ **Direction.java** une classe java inspirée de celle à 4 directions de Luc Hernandez mais pour 8 directions. ++ Exemple.java des exemples d'uilisation de cette implémentation. ++ TestsFournisDirection.java des tests fournis pour corriger Direction.java ++ **TestsACompleterDirection.java** un fichier squelette de tests à compléter. ++ **Reponses.txt** un fichier texte à compléter + +Seuls les fichiers dont les noms sont **en gras** ci-dessus sont à compléter et à rendre. +Pour les modalités, voir ci-dessous. + +## Avant la premioère partie : questions +aller compléter le fichier **Reponses.txt** + +## Première partie : debug +Un certains nombres de tests sont fournis. Vous ne devez pas changer ces derniers. +Vous devez exécuter ces tests puis changer le code de la classe **Direction** idéalement jusqu'à ce que les tests fournis soient satisfaits. + +Chaque ligne de **Direction.java** changée devra être suivi du commentaire //BUGFIX éventuellement suivi de texte +Si il y a plusieurs bugs sur la ligne, vous pouvez les indiquez l'un après l'autre. + +Par exemple : +Pour 1 bug +> return (this.index); //BUGFIX enlevé +1 +Pour 2 bugs +> if (a < b) { //BUGFIX remplacé <= par < //BUGFIX ajouté un crochet. + +**Attention** Le correcteur utilise grep pour corriger et il faut suivre exactement la consigne ci-dessus sans peine de voir son travail évalué à 0. + +## Seconde partie : test +Vous devez compléter le fichier **TestsACompleterDirection.java** +Il n'est pas demandé de changer le code de **Direction.java** pour passer ces nouveaux tests. + + + +## Modalité de rendu +Vous devez rendre votre travail sur devoir +l'url est : +www.iut-fbleau.fr/site/site/DEVOIR/ + +Il faut pour ce faire soumettre une archive tests.tar.gz **contenant uniquement les deux fichiers .java** (on ne veut pas les .class) suivants, édités par vos soins comme indiqué dans les questions ci-dessus : +**Direction.java** +**TestsACompleterDirection.java** +**Reponses.txt** + +Pour ceux qui ont oublié comment faire : + +> bob@box:~$ tar czvvf tests.tar.gz Direction.java TestsACompleterDirection.java Reponses.txt + diff --git a/DEV/DEV2.3/cm3/Reponses.txt~ b/DEV/DEV2.3/controle_original/Reponses.txt similarity index 100% rename from DEV/DEV2.3/cm3/Reponses.txt~ rename to DEV/DEV2.3/controle_original/Reponses.txt diff --git a/DEV/DEV2.3/cm3/TestsACompleterDirection.java~ b/DEV/DEV2.3/controle_original/TestsACompleterDirection.java similarity index 70% rename from DEV/DEV2.3/cm3/TestsACompleterDirection.java~ rename to DEV/DEV2.3/controle_original/TestsACompleterDirection.java index 115a44a..ae964e8 100644 --- a/DEV/DEV2.3/cm3/TestsACompleterDirection.java~ +++ b/DEV/DEV2.3/controle_original/TestsACompleterDirection.java @@ -18,8 +18,9 @@ public class TestsACompleterDirection { */ @Test public void Nordx(){ - Direction d = Direction.NORD; - assertEquals(0,d.getDecalageX()); + // au nord c'était les corons. + + assertEquals(0,Direction.NORD.getDecalageX()); } @@ -28,8 +29,8 @@ public class TestsACompleterDirection { */ @Test public void Nordy(){ - Direction d = Direction.NORD; - assertEquals(-1,d.getDecalageY()); + assertEquals(-1,Direction.NORD.getDecalageY()); + } /** @@ -37,35 +38,24 @@ public class TestsACompleterDirection { */ @Test(expected = NullPointerException.class) public void ResetNPE(){ - Direction.reset(); + Direction.reset(); + } /** * Test que l'on peut faire 64 fois un huitième de tour dans le sens trigonométrique et être au même endroit quand on part du Sud Est */ - @Test public void whenIGetOlder(){ - Direction d1 = Direction.SE; - Direction d2 = Direction.SE; - for (int i=0; i<64; i++){ - d2 = d2.huitDeTour(); - } - assertEquals(d1,d2); + } /** * Test que l'on peut faire 65 fois un huitième detour dans le sens antitrigonométrique et être au même endroit que si on faisait un anti huitième de tour quand on part du Sud Est */ - @Test public void losingMyHair(){ - Direction d1 = Direction.SE; - Direction d2 = Direction.SE; - for (int i=0; i<65; i++){ - d2 = d2.huitDeTour(); - } - assertEquals(d1.huitDeTourAnti(),d2); + } diff --git a/DEV/DEV2.3/controle_original/TestsFournisDirection.class b/DEV/DEV2.3/controle_original/TestsFournisDirection.class new file mode 100644 index 0000000..8cfd2e3 Binary files /dev/null and b/DEV/DEV2.3/controle_original/TestsFournisDirection.class differ diff --git a/DEV/DEV2.3/controle_original/TestsFournisDirection.java b/DEV/DEV2.3/controle_original/TestsFournisDirection.java new file mode 100644 index 0000000..95a7179 --- /dev/null +++ b/DEV/DEV2.3/controle_original/TestsFournisDirection.java @@ -0,0 +1,97 @@ +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.assertEquals; // +import org.junit.Test; + +import java.lang.StringBuilder; + + +/** + * Une classe pour faire des tests sur la classe MaMemoire avec JUnit + */ +public class TestsFournisDirection { + + + /** + * Test quart de tour depuis nord donne l'est. + */ + @Test + public void NordQuartDeTour(){ + Direction d = Direction.NORD; + assertEquals(Direction.EST,d.quartDeTour()); + } + + /** + * Test huit de tour depuis nord donne le nord-est. + */ + @Test + public void NordHuiDeTour(){ + Direction d = Direction.NORD; + assertEquals(Direction.NE,d.huitDeTour()); + } + + /** + * Test deux demi-tours depuis nord. + */ + @Test + public void NordDeuxDemiTour(){ + Direction d = Direction.NORD; + assertEquals(d,d.demiTour().demiTour()); + } + + /** + * Test 4 quart-tours depuis nord. + */ + @Test + public void NordQuatreQuartTour(){ + Direction d = Direction.NORD; + assertEquals(d,d.quartDeTour().quartDeTour().quartDeTour().quartDeTour()); + } + + /** + * Test 1 huit-tour depuis nord suivi d'un huit tour anti. + */ + @Test + public void NordAntiHuitHuit(){ + Direction d = Direction.NORD; + assertEquals(d,d.huitDeTour().huitDeTourAnti()); + } + + /** + * Test 1 huit-tour anti depuis nord suivi d'un huit tour. + */ + @Test + public void NordHuitAntiHuit(){ + Direction d = Direction.NORD; + assertEquals(d,d.huitDeTourAnti().huitDeTour()); + } + + /** + * Test 1 quart-tour depuis nord suivi d'un quart tour anti. + */ + @Test + public void NordAntiQuartQuart(){ + Direction d = Direction.NORD; + assertEquals(d,d.quartDeTour().quartDeTourAnti()); + } + + /** + * Test 1 quart-tour anti depuis nord suivi d'un quart tour. + */ + @Test + public void NordQuartAntiQuart(){ + Direction d = Direction.NORD; + assertEquals(d,d.quartDeTourAnti().quartDeTour()); + } + + /** + * Test 1 huit-tour anti depuis nord donne le Nord Ouest. + */ + @Test + public void NordAntiHuitTour(){ + Direction d = Direction.NORD; + assertEquals(Direction.NE,d.huitDeTourAnti()); // parce qu'il faut bien un test pas très juste + } + + +} diff --git a/DEV/DEV2.3/controle_original/tests.tar.gz b/DEV/DEV2.3/controle_original/tests.tar.gz new file mode 100644 index 0000000..e97bfdd Binary files /dev/null and b/DEV/DEV2.3/controle_original/tests.tar.gz differ diff --git a/DEV/DEV3.2/Controle_Machine_Blanc/Q1_Annulation/Main.java b/DEV/DEV3.2/Controle_Machine_Blanc/Q1_Annulation/Main.java index 08ec9a9..3526ae9 100644 --- a/DEV/DEV3.2/Controle_Machine_Blanc/Q1_Annulation/Main.java +++ b/DEV/DEV3.2/Controle_Machine_Blanc/Q1_Annulation/Main.java @@ -8,4 +8,4 @@ public class Main{ Fenetre fenetre = new Fenetre(); fenetre.setVisible(true); } -} +} \ No newline at end of file diff --git a/DEV/DEV3.2/DEV32/1/Bulle.java b/DEV/DEV3.2/DEV32/1/Bulle.java new file mode 100644 index 0000000..2818c84 --- /dev/null +++ b/DEV/DEV3.2/DEV32/1/Bulle.java @@ -0,0 +1,39 @@ +public class Bulle{ + + public static boolean bulle(File pileRemplis, File pileVide){ + if (pileVide.isEmpty() == false){ + throw new IllegalArgumentException("Erreur : l'argument pileVide n'est pas vide"); + } + + E max, v2; + boolean haveChangement = false; + if (pileRemplis.isEmpty() == false){ + max = pileRemplis.dequeue(); + while (pileRemplis.isEmpty() == false){ + v2 = max; + max = pileRemplis.dequeue(); + if (max < v2){ // changer cette ligne pour rendre les objet comparable + pileVide.enqueue(max); + max = v2; + haveChangement = true; + } + else{ + pileVide.enqueue(v2); + } + } + pileVide.enqueue(max); + } + return haveChangement; + } + + public static File tri(File pile1){ + File pile2 = new File<>(); + File transition = null; + while (Bulle.bulle(pile1, pile2)){ + transition = pile2; + pile2 = pile1; + pile1 = transition; + } + return pile2; + } +} \ No newline at end of file diff --git a/DEV/DEV3.2/DEV32/1/File.class b/DEV/DEV3.2/DEV32/1/File.class new file mode 100644 index 0000000..bfa4f82 Binary files /dev/null and b/DEV/DEV3.2/DEV32/1/File.class differ diff --git a/DEV/DEV3.2/DEV32/1/File.java b/DEV/DEV3.2/DEV32/1/File.java new file mode 100644 index 0000000..8313610 --- /dev/null +++ b/DEV/DEV3.2/DEV32/1/File.java @@ -0,0 +1,22 @@ +import java.util.*; + +public class File{ + + private Queue file; + + public File(){ + this.file = new LinkedList<>(); + } + + public void enqueue(E valeur){ + this.file.offer(valeur); + } + + public E dequeue(){ + return this.file.poll(); + } + + public boolean isEmpty(){ + return this.file.isEmpty(); + } +} \ No newline at end of file diff --git a/DEV/DEV3.2/DEV32/1/Main.class b/DEV/DEV3.2/DEV32/1/Main.class new file mode 100644 index 0000000..a4f4555 Binary files /dev/null and b/DEV/DEV3.2/DEV32/1/Main.class differ diff --git a/DEV/DEV3.2/DEV32/1/Main.java b/DEV/DEV3.2/DEV32/1/Main.java new file mode 100644 index 0000000..3b44238 --- /dev/null +++ b/DEV/DEV3.2/DEV32/1/Main.java @@ -0,0 +1,43 @@ +public class Main{ + public static void main(String[] args){ + int[] tableauEntier = new int[args.length]; + int i; + try{ + //convertion en int + for (i=0; i fileRemplisBulle = new File<>(); + File fileRemplisTri = new File<>(); + File fileVide = new File<>(); + for (int entier : tableauEntier){ + fileRemplisBulle.enqueue(entier); + fileRemplisTri.enqueue(entier); + } + + // methode bulle + Bulle.bulle(fileRemplisBulle, fileVide); + System.out.print("Bulle : "); + while (fileVide.isEmpty() == false){ + System.out.print(fileVide.dequeue() + " "); + } + System.out.println(); + + //methode tri + Bulle.tri(fileRemplisTri); + System.out.print("Tri : "); + while (fileRemplisTri.isEmpty() == false){ + System.out.print(fileRemplisTri.dequeue() + " "); + } + System.out.println(); + } + catch(NumberFormatException e){ + System.out.println("argument invalide"); + } + } +} \ No newline at end of file diff --git a/DEV/DEV3.2/DEV32/2/838_planche06_copie.webp b/DEV/DEV3.2/DEV32/2/838_planche06_copie.webp new file mode 100644 index 0000000..7df1712 Binary files /dev/null and b/DEV/DEV3.2/DEV32/2/838_planche06_copie.webp differ diff --git a/DEV/DEV3.2/DEV32/2/Exemple.java b/DEV/DEV3.2/DEV32/2/Exemple.java new file mode 100644 index 0000000..7a7082c --- /dev/null +++ b/DEV/DEV3.2/DEV32/2/Exemple.java @@ -0,0 +1,49 @@ +public class Exemple{ + + /** + * Exemple d'utilisation de SimpleDequeThatsNotCricket. + * + * @param args pas de paramètre en ligne de commande prévu. + */ + public static void main(String[] args) { + + MinimalDeque 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/DEV/DEV3.2/DEV32/2/MaillonDouble.class b/DEV/DEV3.2/DEV32/2/MaillonDouble.class new file mode 100644 index 0000000..6c61d44 Binary files /dev/null and b/DEV/DEV3.2/DEV32/2/MaillonDouble.class differ diff --git a/DEV/DEV3.2/DEV32/2/MaillonDouble.java b/DEV/DEV3.2/DEV32/2/MaillonDouble.java new file mode 100644 index 0000000..585122d --- /dev/null +++ b/DEV/DEV3.2/DEV32/2/MaillonDouble.java @@ -0,0 +1,30 @@ +public class MaillonDouble { + + private MaillonDouble suivant = null; + private MaillonDouble precedent = null; + private E valeur; + + public MaillonDouble(E valeur){ + this.valeur = valeur; + } + + public E getValeur(){ + return this.valeur; + } + + public MaillonDouble suivant(){ + return this.suivant; + } + + public MaillonDouble precedent(){ + return this.precedent; + } + + public void setSuivant(MaillonDouble suivant){ + this.suivant = suivant; + } + + public void setPrecedent(MaillonDouble precedent){ + this.precedent = precedent; + } +} \ No newline at end of file diff --git a/DEV/DEV3.2/DEV32/2/MinimalDeque.class b/DEV/DEV3.2/DEV32/2/MinimalDeque.class new file mode 100644 index 0000000..90856f0 Binary files /dev/null and b/DEV/DEV3.2/DEV32/2/MinimalDeque.class differ diff --git a/DEV/DEV3.2/DEV32/2/MinimalDeque.java b/DEV/DEV3.2/DEV32/2/MinimalDeque.java new file mode 100644 index 0000000..e1b75ca --- /dev/null +++ b/DEV/DEV3.2/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/DEV/DEV3.2/DEV32/2/QuestionsTest.txt b/DEV/DEV3.2/DEV32/2/QuestionsTest.txt new file mode 100644 index 0000000..3d596e4 --- /dev/null +++ b/DEV/DEV3.2/DEV32/2/QuestionsTest.txt @@ -0,0 +1,77 @@ +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] + + ... + + b) Comment fonctionne cette classe? + [1 point] + + ... + +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 + => F + + a2) Il est possible de décider si un programme C va s'arrêter quelle que soit son entrée. + V/F + => F + + a3) Il est possible de décider si un programme python ne va pas s'arrêter pour certaines entrées. + V/F + => V + + 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 + => V + + 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 + => 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 + => 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 -cp junit.jar:hamcrest-core.jar org.junit.runner.JUnitCore + + 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? + + => CLASSPATH=".:/usr/share/java/junit.jar:/usr/share/java/hamcrest-core.jar" + java -cp $CLASSPATH org.junit.runner.JUnitCore + + +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/DEV/DEV3.2/DEV32/2/README.txt b/DEV/DEV3.2/DEV32/2/README.txt new file mode 100644 index 0000000..676fdec --- /dev/null +++ b/DEV/DEV3.2/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/DEV/DEV3.2/DEV32/2/SimpleDeque.class b/DEV/DEV3.2/DEV32/2/SimpleDeque.class new file mode 100644 index 0000000..f62624c Binary files /dev/null and b/DEV/DEV3.2/DEV32/2/SimpleDeque.class differ diff --git a/DEV/DEV3.2/DEV32/2/SimpleDeque.java b/DEV/DEV3.2/DEV32/2/SimpleDeque.java new file mode 100644 index 0000000..0017323 --- /dev/null +++ b/DEV/DEV3.2/DEV32/2/SimpleDeque.java @@ -0,0 +1,106 @@ +import javax.sql.rowset.spi.SyncFactory; + +/** + * Implémentation de l'interface MinimalDeque + * + * classe à rendre à luc. + * + * @author vous + * @see Java.util.Deque + */ +public class SimpleDeque implements MinimalDeque{ + + private MaillonDouble debut; + private MaillonDouble fin; + + public SimpleDeque(){ + } + + @Override + public void addFirst(E e){ + if (e == null){ + throw new NullPointerException("argument null"); + } + MaillonDouble premier = new MaillonDouble<>(e); + if (this.debut == null){ + this.debut = premier; + this.fin = premier; + + } + else{ + this.debut.setPrecedent(premier); + premier.setSuivant(this.debut); + this.debut = premier; + } + } + + @Override + public void addLast(E e){ + if (e == null){ + throw new NullPointerException("argument null"); + } + MaillonDouble dernier = new MaillonDouble<>(e); + if (this.fin == null){ + this.fin = dernier; + this.debut = dernier; + } + else{ + this.fin.setSuivant(dernier); + dernier.setPrecedent(this.fin); + this.fin = dernier; + } + } + + @Override + public boolean isEmpty(){ + if (this.fin == null && this.debut == null){ + return true; + } + return false; + } + + @Override + public E removeFirst(){ + if (this.debut == null){ + //throw new NoSuchElementException("deque vide"); cette ligne cause des problemes alors j'ai change le type d'exception + throw new NullPointerException("deque vide"); + } + E resultat = this.debut.getValeur(); + this.debut = this.debut.suivant(); + if (this.debut != null){ + this.debut.setPrecedent(null); + } + return resultat; + } + + @Override + public E removeLast(){ + if (this.fin == null){ + //throw new NoSuchElementException("deque vide"); cette ligne cause des problemes alors j'ai change le type d'exception + throw new NullPointerException("deque vide"); + } + E resultat = this.fin.getValeur(); + this.fin = this.fin.precedent(); + if (this.fin != null){ + this.fin.setSuivant(null); + } + return resultat; + } + + @Override + public String toString(){ + MaillonDouble maillonActuel = this.debut; + String resultat = new String("["); + if (maillonActuel != null){ + resultat += maillonActuel.getValeur(); + maillonActuel = maillonActuel.suivant(); + } + while (maillonActuel != null){ + resultat += ", " + maillonActuel.getValeur(); + maillonActuel = maillonActuel.suivant(); + } + resultat += "]"; + return resultat; + } + +} diff --git a/DEV/DEV3.2/DEV32/2/SimpleDequeThatsNotCricket.java b/DEV/DEV3.2/DEV32/2/SimpleDequeThatsNotCricket.java new file mode 100644 index 0000000..e0f0744 --- /dev/null +++ b/DEV/DEV3.2/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/DEV/DEV3.2/DEV32/2/TestSimpleDeque.class b/DEV/DEV3.2/DEV32/2/TestSimpleDeque.class new file mode 100644 index 0000000..286a93f Binary files /dev/null and b/DEV/DEV3.2/DEV32/2/TestSimpleDeque.class differ diff --git a/DEV/DEV3.2/DEV32/2/TestSimpleDeque.java b/DEV/DEV3.2/DEV32/2/TestSimpleDeque.java new file mode 100644 index 0000000..798a46f --- /dev/null +++ b/DEV/DEV3.2/DEV32/2/TestSimpleDeque.java @@ -0,0 +1,183 @@ +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(expected = NullPointerException.class) + public void addFirstNull(){ + MinimalDeque d = new SimpleDeque(); + + d.addFirst(null); + } + + /** + * On ne peut pas ajouter avec addLast l'élément null + * [0.5 point] + */ + @Test(expected = NullPointerException.class) + public void addLastNull(){ + MinimalDeque d = new SimpleDeque(); + d.addLast(null); + + } + + /** + * Un deque sans élément est vide. + * [0.5 point] + */ + @Test + public void addNoneIsEmpty(){ + MinimalDeque d = new SimpleDeque(); + assertTrue(d.isEmpty()); + } + + /** + * Un deque avec 1 élément n'est pas vide. + * [0.5 point] + */ + @Test + public void addOneIsNotEmpty(){ + MinimalDeque d = new SimpleDeque(); + d.addFirst("meu"); + assertFalse(d.isEmpty()); + + } + + + /** + * 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"; + d.addFirst(ga); + d.addFirst(bu); + d.addFirst(zo); + d.addFirst(meu); + assertSame(ga,d.removeLast()); + assertSame(bu,d.removeLast()); + assertSame(zo,d.removeLast()); + assertSame(meu,d.removeLast()); + + } + + /** + * 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(){ + MinimalDeque d = new SimpleDeque(); + String ga = "ga"; + String bu = "bu"; + String zo = "zo"; + String meu = "meu"; + d.addLast(ga); + d.addLast(bu); + d.addLast(zo); + d.addLast(meu); + assertSame(ga,d.removeFirst()); + assertSame(bu,d.removeFirst()); + assertSame(zo,d.removeFirst()); + assertSame(meu,d.removeFirst()); + } + + /** + * On ne peut pas enlever d'élément devant d'un deque vide. + * [1 point] + */ + @Test(expected = NullPointerException.class) + public void removeFirstFromEmpty(){ + MinimalDeque d = new SimpleDeque(); + d.removeFirst(); + } + + /** + * On ne peut pas enlever d'élément derrière d'un deque vide. + * [1 point] + */ + @Test(expected = NullPointerException.class) + public void removeLastFromEmpty(){ + MinimalDeque d = new SimpleDeque(); + d.removeLast(); + } + + /** + * 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"; + String ga1, ga2; + d.addFirst(ga); + ga1 = d.removeFirst(); + d.addLast(ga); + ga2 = d.removeLast(); + assertSame(ga1,ga2); + + } + + + /** + * 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(900)+100; + int i; + for (i=0; i