Rendu final TP2

TP2/src/main/java/arraydoubleendedqueue/ArrayDoubleEndedQueue.java

@@ -2,66 +2,108 @@ package arraydoubleendedqueue;
 
 import deque.DoubleEndedQueue;
 
+import java.util.NoSuchElementException;
+
 public class ArrayDoubleEndedQueue<E> implements DoubleEndedQueue {
     private Object[] elements;
     private int size;
     private int capacity;
 
+    private int indexFirst;
+
     public ArrayDoubleEndedQueue(int capacity) {
         this.capacity = capacity;
         elements = new Object[capacity];
         this.size = 0;
+        this.indexFirst = 0;
     }
 
     @Override
     public void addFirst(Object o) {
-        if(size < capacity) {
-            elements[size] = o;
-            size++;
+        if(size == capacity) {
+            throw new IllegalStateException("La queue est pleine");
         }
         else {
-            throw new IllegalStateException("Queue is full");
+            elements[size] = o;
+            size++;
+
         }
     }
 
     @Override
     public void addLast(Object o) {
-        if(size < capacity) {
-            elements[size] = o;
-            size++;
+        if(size == capacity) {
+            throw new IllegalStateException("La queue est pleine");
+
         }
         else {
-            throw new IllegalStateException("Queue is full");
+            elements[size] = o;
+            size++;
         }
     }
 
     @Override
     public Object removeFirst() {
-
+        if (size == 0) {
+            throw new NoSuchElementException("La queue est vide");
+        }
+        Object removedElement = (Object) elements[indexFirst];
+        elements[indexFirst] = null;
+        indexFirst = (indexFirst + 1) % capacity;
+        size--;
+        return removedElement;
     }
 
     @Override
     public Object removeLast() {
-        return null;
+        if (size == 0) {
+            throw new NoSuchElementException("La queue est vide");
+        }
+        int lastIndex = (indexFirst + size - 1) % capacity;
+        Object removedElement = (Object) elements[lastIndex];
+        elements[lastIndex] = null;
+        size--;
+        return removedElement;
     }
 
     @Override
     public Object getFirst() {
-        return null;
+        if (size == 0) {
+            throw new NoSuchElementException("La queue est vide");
+        }
+        return (Object) elements[indexFirst];
     }
 
     @Override
     public Object getLast() {
-        return null;
+        if (size == 0) {
+            throw new NoSuchElementException("La queue est vide");
+        }
+        return (Object) elements[((indexFirst + size - 1) % capacity)];
     }
 
     @Override
     public int size() {
-        return 0;
+        return size;
     }
 
     @Override
     public boolean contains(Object o) {
+        if (o == null) {
+            for (int i = 0; i < size; i++) {
+                if (elements[(indexFirst + i) % capacity] == null) {
+                    return true;
+                }
+            }
+        } else {
+            for (int i = 0; i < size; i++) {
+                if (o.equals(elements[(indexFirst + i) % capacity])) {
+                    return true;
+                }
+            }
+        }
         return false;
     }
+
+
 }

TP2/src/test/java/arraydoubleendedqueue/ArrayDoubleEndedQueueTest.java

@@ -6,9 +6,14 @@ import org.junit.jupiter.api.Test;
 import java.util.Deque;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class ArrayDoubleEndedQueueTest {
-    static Deque<Integer> ArrayDoubleEndedQueue;
+    static ArrayDoubleEndedQueue<Integer> arrayDoubleEndedQueue;
+    static ArrayDoubleEndedQueue<Integer> queueVide;
+
+
     @BeforeAll
     static void setUpBeforeClass() throws Exception {
         System.out.println("Before all");
@@ -21,6 +26,9 @@ public class ArrayDoubleEndedQueueTest {
 
     @BeforeEach
     void setUp() throws Exception {
+        arrayDoubleEndedQueue = new ArrayDoubleEndedQueue<>(10);
+        queueVide = new ArrayDoubleEndedQueue<>(10);
+
     }
 
     @AfterEach
@@ -30,46 +38,92 @@ public class ArrayDoubleEndedQueueTest {
 
     @Test
     void testAddFirst() {
-        ArrayDoubleEndedQueue.addFirst(1);
-        ArrayDoubleEndedQueue.addFirst(2);
-        ArrayDoubleEndedQueue.addFirst(3);
-        ArrayDoubleEndedQueue.addFirst(4);
-        assertThat(ArrayDoubleEndedQueue.getFirst()).isEqualTo(1);
+        arrayDoubleEndedQueue.addFirst(1);
+        arrayDoubleEndedQueue.addFirst(2);
+        arrayDoubleEndedQueue.addFirst(3);
+        arrayDoubleEndedQueue.addFirst(4);
+        arrayDoubleEndedQueue.addFirst(5);
+        arrayDoubleEndedQueue.addFirst(6);
+        arrayDoubleEndedQueue.addFirst(7);
+        assertThat(arrayDoubleEndedQueue.getFirst()).isEqualTo(1);
     }
 
     @Test
     void testAddLast() {
-        ArrayDoubleEndedQueue.addLast(1);
-        ArrayDoubleEndedQueue.addLast(2);
-        ArrayDoubleEndedQueue.addLast(3);
-        ArrayDoubleEndedQueue.addLast(4);
-        assertThat(ArrayDoubleEndedQueue.getLast()).isEqualTo(4);
+        arrayDoubleEndedQueue.addLast(1);
+        arrayDoubleEndedQueue.addLast(2);
+        arrayDoubleEndedQueue.addLast(3);
+        arrayDoubleEndedQueue.addLast(4);
+        assertThat(arrayDoubleEndedQueue.getLast()).isEqualTo(4);
     }
 
     @Test
     void testRemoveFirst() {
+        arrayDoubleEndedQueue.addLast('X');
+        arrayDoubleEndedQueue.addLast('Y');
+
+        assertEquals('X', arrayDoubleEndedQueue.removeFirst());
 
 
     }
 
     @Test
     void testRemoveLast() {
+        arrayDoubleEndedQueue.addLast(1);
+        arrayDoubleEndedQueue.addLast(2);
+        arrayDoubleEndedQueue.addLast(3);
+        arrayDoubleEndedQueue.addFirst(4);
+
+        assertEquals(4, arrayDoubleEndedQueue.removeLast());
     }
 
     @Test
     void testGetFirst() {
+        arrayDoubleEndedQueue.addLast(10);
+
+        assertEquals(10, arrayDoubleEndedQueue.getFirst());
     }
 
     @Test
     void testGetLast() {
+        arrayDoubleEndedQueue.addLast(10);
+
+        assertEquals(10, arrayDoubleEndedQueue.getLast());
     }
 
     @Test
     void testSize() {
+        arrayDoubleEndedQueue.addLast(10);
+        arrayDoubleEndedQueue.addLast(11);
+        arrayDoubleEndedQueue.addLast(12);
+        arrayDoubleEndedQueue.addLast(13);
+        arrayDoubleEndedQueue.addLast(14);
+        arrayDoubleEndedQueue.addLast(15);
+        arrayDoubleEndedQueue.addLast(16);
+        arrayDoubleEndedQueue.addLast(19);
+
+
+        assertEquals(8, arrayDoubleEndedQueue.size());
     }
 
     @Test
     void testContains() {
+        arrayDoubleEndedQueue.addLast(10);
+        arrayDoubleEndedQueue.addLast(11);
+        arrayDoubleEndedQueue.addLast(12);
+        arrayDoubleEndedQueue.addLast(13);
+        arrayDoubleEndedQueue.addLast(14);
+        arrayDoubleEndedQueue.addLast(15);
+        arrayDoubleEndedQueue.addLast(16);
+        arrayDoubleEndedQueue.addLast(19);
+
+        assertTrue(arrayDoubleEndedQueue.contains(10));
+        assertEquals(false, arrayDoubleEndedQueue.contains(20));
+        assertEquals(false, arrayDoubleEndedQueue.contains(null));
+        queueVide.addLast(null);
+        System.out.println(queueVide.getFirst());
+        assertEquals(true, queueVide.contains(null));
     }
 
+
 }
\ No newline at end of file