wamster/BUT2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

controle machine

Browse Source
This commit is contained in:
Alexis WAMSTER 2023-12-21 16:36:03 +01:00
parent b1a83ffc24
commit 2d9560a691
48 changed files with 906 additions and 555 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
DEV/DEV2.3/TP02_JUnit/Largest.java~
View File

BIN
DEV/DEV2.3/TP02_JUnit/ex1/AssertTests.class
View File

Binary file not shown.

106
DEV/DEV2.3/TP02_JUnit/ex1/AssertTests.java~
View File

@ -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.<Integer> either(equalTo(3)).or(equalTo(4))));
assertThat(new Object(), not(sameInstance(new Object())));
}
@Test
public void testAssertTrue() {
assertTrue("failure - should be true", true);
}
}

BIN
DEV/DEV2.3/TP02_JUnit/ex1/Calculator.class
View File

Binary file not shown.

30
DEV/DEV2.3/TP02_JUnit/ex1/Calculator.java~
View File

@ -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]));
}
}

BIN
DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest0.class
View File

Binary file not shown.

BIN
DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest1.class
View File

Binary file not shown.

18
DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest1.java~
View File

@ -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
}
}

BIN
DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest2.class
View File

Binary file not shown.

BIN
DEV/DEV2.3/TP02_JUnit/ex1/CalculatorTest3.class
View File

Binary file not shown.

BIN
DEV/DEV2.3/TP02_JUnit/ex2/Largest.class
View File

Binary file not shown.

18
DEV/DEV2.3/TP02_JUnit/ex2/Largest.java~
View File

@ -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;
}
}

BIN
DEV/DEV2.3/TP02_JUnit/ex2/TestLargest.class
View File

Binary file not shown.

10
DEV/DEV2.3/TP02_JUnit/ex2/TestLargest.java~
View File

@ -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}));
}
}

38
DEV/DEV2.3/cm1/Reponses.txt
View File

@ -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 <fichierTest.java>
java -cp $CLASSPATH org.junit.runner.JUnitCore <fichierTest.class>
========================================================================================
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)
========================================================================================

75
DEV/DEV2.3/cm1/TestsACompleterDirection.java
View File

@ -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);
}
}

226
DEV/DEV2.3/cm3/Direction.java~
View File

@ -1,226 +0,0 @@
import java.util.Objects;
/**
* La classe <code>Direction</code>, 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");
}
}

6
DEV/DEV2.3/cm3/TestsACompleterDirection.java
View File

@ -68,6 +68,12 @@ public class TestsACompleterDirection {
assertEquals(d1.huitDeTourAnti(),d2);
}
@Test
public void test1(){
boolean var = true;
assert(var);
}

BIN
DEV/DEV2.3/controle_original/Direction.class Normal file
View File

Binary file not shown.

27
DEV/DEV2.3/cm1/Direction.java → DEV/DEV2.3/controle_original/Direction.java
View File

@ -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];
}
}

38
DEV/DEV2.3/controle_original/Exemple.java Normal file
View File

@ -0,0 +1,38 @@
/**
* Mise en oeuvre de la classe <code>Direction</code>, 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);
}
}

53
DEV/DEV2.3/controle_original/README.md Normal file
View File

@ -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

0
DEV/DEV2.3/cm3/Reponses.txt~ → DEV/DEV2.3/controle_original/Reponses.txt
View File

28
DEV/DEV2.3/cm3/TestsACompleterDirection.java~ → DEV/DEV2.3/controle_original/TestsACompleterDirection.java
View File

@ -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);
}

BIN
DEV/DEV2.3/controle_original/TestsFournisDirection.class Normal file
View File

Binary file not shown.

97
DEV/DEV2.3/controle_original/TestsFournisDirection.java Normal file
View File

@ -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
}
}

BIN
DEV/DEV2.3/controle_original/tests.tar.gz Normal file
View File

Binary file not shown.

2
DEV/DEV3.2/Controle_Machine_Blanc/Q1_Annulation/Main.java
View File

@ -8,4 +8,4 @@ public class Main{
Fenetre fenetre = new Fenetre();
fenetre.setVisible(true);
}
}
}

39
DEV/DEV3.2/DEV32/1/Bulle.java Normal file
View File

@ -0,0 +1,39 @@
public class Bulle{
public static <E> boolean bulle(File<E> pileRemplis, File<E> 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 <E> File<E> tri(File<E> pile1){
File<E> pile2 = new File<>();
File<E> transition = null;
while (Bulle.bulle(pile1, pile2)){
transition = pile2;
pile2 = pile1;
pile1 = transition;
}
return pile2;
}
}

BIN
DEV/DEV3.2/DEV32/1/File.class Normal file
View File

Binary file not shown.

22
DEV/DEV3.2/DEV32/1/File.java Normal file
View File

@ -0,0 +1,22 @@
import java.util.*;
public class File<E>{
private Queue<E> 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();
}
}

BIN
DEV/DEV3.2/DEV32/1/Main.class Normal file
View File

Binary file not shown.

43
DEV/DEV3.2/DEV32/1/Main.java Normal file
View File

@ -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<args.length; i++){
tableauEntier[i] = Integer.parseInt(args[i]);
if (tableauEntier[i] < 0){
throw new NumberFormatException("Erreur : l'entier naturel saisis est negatif "+tableauEntier[i]);
}
}
//remplissage
File<Integer> fileRemplisBulle = new File<>();
File<Integer> fileRemplisTri = new File<>();
File<Integer> 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");
}
}
}

BIN
DEV/DEV3.2/DEV32/2/838_planche06_copie.webp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 75 KiB

49
DEV/DEV3.2/DEV32/2/Exemple.java Normal file
View File

@ -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<String> d = new SimpleDequeThatsNotCricket<String>();
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("");
}
}

BIN
DEV/DEV3.2/DEV32/2/MaillonDouble.class Normal file
View File

Binary file not shown.

30
DEV/DEV3.2/DEV32/2/MaillonDouble.java Normal file
View File

@ -0,0 +1,30 @@
public class MaillonDouble <E>{
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<E> suivant(){
return this.suivant;
}
public MaillonDouble<E> precedent(){
return this.precedent;
}
public void setSuivant(MaillonDouble<E> suivant){
this.suivant = suivant;
}
public void setPrecedent(MaillonDouble<E> precedent){
this.precedent = precedent;
}
}

BIN
DEV/DEV3.2/DEV32/2/MinimalDeque.class Normal file
View File

Binary file not shown.

68
DEV/DEV3.2/DEV32/2/MinimalDeque.java Normal file
View File

@ -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<E> {
/**
* 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 <tt>true</tt> if this collection contains no elements.
*
* @return <tt>true</tt> 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();
}

77
DEV/DEV3.2/DEV32/2/QuestionsTest.txt Normal file
View File

@ -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.

20
DEV/DEV3.2/DEV32/2/README.txt Normal file
View File

@ -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.

BIN
DEV/DEV3.2/DEV32/2/SimpleDeque.class Normal file
View File

Binary file not shown.

106
DEV/DEV3.2/DEV32/2/SimpleDeque.java Normal file
View File

@ -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 <E> implements MinimalDeque<E>{
private MaillonDouble<E> debut;
private MaillonDouble<E> fin;
public SimpleDeque(){
}
@Override
public void addFirst(E e){
if (e == null){
throw new NullPointerException("argument null");
}
MaillonDouble<E> 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<E> 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<E> 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;
}
}

52
DEV/DEV3.2/DEV32/2/SimpleDequeThatsNotCricket.java Normal file
View File

@ -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<E> implements MinimalDeque<E>{
/**
* attribut à qui on va déléguer le travail.
*/
private Deque<E> d;
public SimpleDequeThatsNotCricket(){
this.d = new LinkedList<E>();
}
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();
}
}

BIN
DEV/DEV3.2/DEV32/2/TestSimpleDeque.class Normal file
View File

Binary file not shown.

183
DEV/DEV3.2/DEV32/2/TestSimpleDeque.java Normal file
View File

@ -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<String> d = new SimpleDeque<String>();
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<String> d = new SimpleDeque<String>();
d.addLast(null);
}
/**
* Un deque sans élément est vide.
* [0.5 point]
*/
@Test
public void addNoneIsEmpty(){
MinimalDeque<String> d = new SimpleDeque<String>();
assertTrue(d.isEmpty());
}
/**
* Un deque avec 1 élément n'est pas vide.
* [0.5 point]
*/
@Test
public void addOneIsNotEmpty(){
MinimalDeque<String> d = new SimpleDeque<String>();
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<String> d = new SimpleDeque<String>();
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<String> d = new SimpleDeque<String>();
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<String> d = new SimpleDeque<String>();
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<String> d = new SimpleDeque<String>();
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<String> d = new SimpleDeque<String>();
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<String> d = new SimpleDeque<String>();
String[] s = {"ga","bu","zo","meu"};
Random rd = new Random();
int N = rd.nextInt(900)+100;
int i;
for (i=0; i<N; i++){
int indice = rd.nextInt(3);
d.addFirst(s[indice]);
}
for (i=0; i<N; i++){
d.removeLast();
}
assertTrue(d.isEmpty());
// rd.nextBoolean())
// s[rd.nextInt(4)])
}
}

BIN
DEV/DEV3.2/wamster_32.tar.gz Normal file
View File

Binary file not shown.

BIN
DEV/DEV_Madelaine/Shadock_couliior/Main.class
View File

Binary file not shown.