controle machine

DEV/DEV2.3/controle_original/Direction.java

@@ -0,0 +1,225 @@
+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);
+
+    /**
+     * 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 = y;
+        this.decalageY = x;
+    }
+  
+    /**
+     * 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 -1; i++) {
+            if (this == this.DirectionsInTrigOrder[i])
+                return this.DirectionsInTrigOrder[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+=2) {
+            if (this == this.DirectionsInTrigOrder[i]){}
+                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 = 1; i < this.DirectionsInTrigOrder.length; i++) {
+            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-1])
+                return this.DirectionsInTrigOrder[(i+8-2)];
+            
+        }
+        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.DirectionsInTrigOrder[(i+5)% 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() {
+    //     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");
+    }
+    
+}

DEV/DEV2.3/controle_original/Exemple.java

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

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 
+

DEV/DEV2.3/controle_original/Reponses.txt

@@ -0,0 +1,37 @@
+// 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 :
+
+
+
+
+========================================================================================
+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 :
+
+
+
+
+========================================================================================
+Question 3.
+Comment puis-je tester si une méthode retourne une exception avec JUnit?
+
+Votre réponse :
+
+
+
+
+
+
+
+
+
+
+
+========================================================================================

DEV/DEV2.3/controle_original/TestsACompleterDirection.java

@@ -0,0 +1,65 @@
+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(){
+        // au nord c'était les corons.
+
+        assertEquals(0,Direction.NORD.getDecalageX());
+
+    }
+
+    /**
+     * Test nord y vaut -1
+     */
+    @Test
+    public void Nordy(){
+        assertEquals(-1,Direction.NORD.getDecalageY());
+
+    }
+
+    /**
+     * 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
+     */
+    public void whenIGetOlder(){
+
+    }
+
+
+    /**
+     * 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
+     */
+    public void losingMyHair(){
+
+    }
+
+    
+    
+
+    
+}

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