ajout crypto

DEV3.2/ancien_controle/controle_unit/TestSimpleDeque.java

@@ -0,0 +1,155 @@
+import static org.junit.Assert.assertTrue;
+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 utilise 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<>();
+        d.addFirst(null); // Doit lancer une exception
+    }
+
+    /**
+     * 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<>();
+        d.addLast(null); // Doit lancer une exception
+    }
+
+    /**
+     * Un deque sans élément est vide.
+     * [0.5 point]
+     */
+    @Test
+    public void addNoneIsEmpty() {
+        MinimalDeque<String> d = new SimpleDeque<>();
+        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<>();
+        d.addFirst("test");
+        assertFalse(d.isEmpty());
+    }
+
+    /**
+     * Ajouter devant et enlever à la fin respecte l'ordre.
+     * [1 point]
+     */
+    @Test
+    public void pasDeResquilleur() {
+        MinimalDeque<String> d = new SimpleDeque<>();
+        d.addFirst("meu");
+        d.addFirst("zo");
+        d.addFirst("bu");
+        d.addFirst("ga");
+
+        assertSame("ga", d.removeLast());
+        assertSame("bu", d.removeLast());
+        assertSame("zo", d.removeLast());
+        assertSame("meu", d.removeLast());
+    }
+
+    /**
+     * Ajouter derrière et enlever au début respecte l'ordre.
+     * [1 point]
+     */
+    @Test
+    public void pasDeResquilleurQuantique() {
+        MinimalDeque<String> d = new SimpleDeque<>();
+        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 devant un deque vide.
+     * [1 point]
+     */
+    @Test(expected = NoSuchElementException.class)
+    public void removeFirstFromEmpty() {
+        MinimalDeque<String> d = new SimpleDeque<>();
+        d.removeFirst();
+    }
+
+    /**
+     * On ne peut pas enlever derrière un deque vide.
+     * [1 point]
+     */
+    @Test(expected = NoSuchElementException.class)
+    public void removeLastFromEmpty() {
+        MinimalDeque<String> d = new SimpleDeque<>();
+        d.removeLast();
+    }
+
+    /**
+     * Ajouter et enlever un seul élément dans les deux sens donne le même résultat.
+     * [2 point]
+     */
+    @Test
+    public void mangerLaBananeParLesDeuxBouts() {
+        MinimalDeque<String> d = new SimpleDeque<>();
+        d.addFirst("ga");
+
+        assertSame("ga", d.removeFirst());
+        d.addLast("ga");
+        assertSame("ga", d.removeLast());
+    }
+
+    /**
+     * Invariant de taille
+     * [4 point]
+     */
+    @Test
+    public void invariantTaille() {
+        MinimalDeque<String> d = new SimpleDeque<>();
+        String[] elements = {"ga", "bu", "zo", "meu"};
+        Random random = new Random();
+        int N = random.nextInt(901) + 100;
+
+        for (int i = 0; i < N; i++) {
+            if (random.nextBoolean()) {
+                d.addFirst(elements[random.nextInt(elements.length)]);
+            } else {
+                d.addLast(elements[random.nextInt(elements.length)]);
+            }
+        }
+
+        for (int i = 0; i < N; i++) {
+            if (random.nextBoolean()) {
+                d.removeFirst();
+            } else {
+                d.removeLast();
+            }
+        }
+
+        assertTrue(d.isEmpty());
+    }
+}