update

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

+package arraydoubleendedqueue;
+
+import deque.DoubleEndedQueue;
+
+public class ArrayDoubleEndedQueue<E> implements DoubleEndedQueue {
+    @Override
+    public void addFirst(Object o) {
+
+    }
+
+    @Override
+    public void addLast(Object o) {
+
+    }
+
+    @Override
+    public Object removeFirst() {
+        return null;
+    }
+
+    @Override
+    public Object removeLast() {
+        return null;
+    }
+
+    @Override
+    public Object getFirst() {
+        return null;
+    }
+
+    @Override
+    public Object getLast() {
+        return null;
+    }
+
+    @Override
+    public int size() {
+        return 0;
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        return false;
+    }
+}

TP2/src/main/java/complex/Complex.java

@@ -7,9 +7,6 @@ public class Complex {
 
     private static final float EPSILON = 0.000001F;
 
-    public Complex() {
-    }
-
     public Complex(float a, float b) {
         this.realPart = a;
         this.imaginaryPart = b;
@@ -41,8 +38,8 @@ public class Complex {
     }
 
     public Complex product(Complex c) {
-        return new Complex();
-        //return new Complex(this.realPart * c.getRealPart() - this.imaginaryPart * c.getImaginaryPart(), this.realPart * c.getImaginaryPart() + this.imaginaryPart * c.getRealPart());
+        //return new Complex();
+        return new Complex(this.realPart * c.getRealPart() - this.imaginaryPart * c.getImaginaryPart(), this.realPart * c.getImaginaryPart() + this.imaginaryPart * c.getRealPart());
     }
 
     public Complex inverse() throws IllegalArgumentException {
@@ -58,6 +55,6 @@ public class Complex {
 
     public static void infinite()
     {
-        //while (true);
+        while (true);
     }
 }

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

+package arraydoubleendedqueue;
+import org.junit.jupiter.api.*;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Deque;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ArrayDoubleEndedQueueTest {
+    static Deque<Integer> ArrayDoubleEndedQueue;
+    @BeforeAll
+    static void setUpBeforeClass() throws Exception {
+        System.out.println("Before all");
+    }
+
+    @AfterAll
+    static void tearDownAfterClass() throws Exception {
+        System.out.println("After all");
+    }
+
+    @BeforeEach
+    void setUp() throws Exception {
+    }
+
+    @AfterEach
+    void tearDown() throws Exception {
+        System.out.println("After each");
+    }
+
+    @Test
+    void testAddFirst() {
+        ArrayDoubleEndedQueue.addFirst(1);
+        ArrayDoubleEndedQueue.addFirst(2);
+        ArrayDoubleEndedQueue.addFirst(3);
+        ArrayDoubleEndedQueue.addFirst(4);
+        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);
+    }
+
+    @Test
+    void testRemoveFirst() {
+
+    }
+
+    @Test
+    void testRemoveLast() {
+    }
+
+    @Test
+    void testGetFirst() {
+    }
+
+    @Test
+    void testGetLast() {
+    }
+
+    @Test
+    void testSize() {
+    }
+
+    @Test
+    void testContains() {
+    }
+
+}
\ No newline at end of file

TP2/src/test/java/complex/ComplexTest.java

@@ -2,6 +2,7 @@ package complex;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.within;
+import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively;
 import static org.junit.jupiter.api.Assertions.fail;
 
 import org.junit.jupiter.api.AfterAll;
@@ -19,48 +20,48 @@ import java.sql.SQLOutput;
  */
 
 class ComplexTest {
-  /*
+
   private Complex z;
   private Complex z1;
   private Complex z2;
-  */
+
   private static final float EPSILON = 0.000001F;
 
 
   @BeforeAll
   static void setUpBeforeClass() throws Exception {
     // TODO: add message
-    //System.out.println("La méthode setUpBeforeClass est bien exécutée avant les tests ");
+    System.out.println("La méthode setUpBeforeClass est bien exécutée avant les tests ");
   }
 
   @AfterAll
   static void tearDownAfterClass() throws Exception {
     // TODO: add message
-    //System.out.println("La méthode tearDownAfterClass est bien exécutée après les tests");
+    System.out.println("La méthode tearDownAfterClass est bien exécutée après les tests");
   }
 
   @BeforeEach
   void setUp() throws Exception {
     // TODO: add message
     System.out.println("setUp effectué avant chaque test");
-    /*
+
     this.z = new Complex(1.0F, 2.0F);
     this.z1 = new Complex(1.0F, 2.0F);
     this.z2 = new Complex(3.0F, 4.0F);
-    */
+
   }
 
   @AfterEach
   void tearDown() throws Exception {
     // TODO: add messageDisabled
-    //System.out.println("tearDown effectué apres chaque test");
+    System.out.println("tearDown effectué apres chaque test");
   }
 
   @Test
   void testGetterImaginary() {
     //System.out.println("1er test");
     float expected = 2.0F;
-    Complex z = new Complex(1.0F, 2.0f); // à supprimer si on mutualise avec BeforeAll
+    //Complex z = new Complex(1.0F, 2.0f); // à supprimer si on mutualise avec BeforeAll
 
     assertThat(z.getImaginaryPart()).as("problem on getter imaginary")
             .isCloseTo(expected, within(EPSILON));
@@ -71,7 +72,7 @@ class ComplexTest {
   void testGetterReal() {
 
     float expected = 1.0F;
-    Complex z = new Complex(1.0F, 2.0f); // à supprimer si on mutualise avec BeforeAll
+    //Complex z = new Complex(1.0F, 2.0f); // à supprimer si on mutualise avec BeforeAll
 
     assertThat(z.getRealPart()).as("problem on getter real")
             .isCloseTo(expected, within(EPSILON));
@@ -82,7 +83,7 @@ class ComplexTest {
   void testSetterImaginary() {
 
     float expected = 3.0F;
-    Complex z = new Complex(); // à supprimer si on mutualise avec BeforeAll
+    //Complex z = new Complex(); // à supprimer si on mutualise avec BeforeAll
     z.setImaginaryPart(expected);
     assertThat(z.getImaginaryPart()).as("problem on setter imaginary")
             .isCloseTo(expected, within(EPSILON));
@@ -94,7 +95,7 @@ class ComplexTest {
   void testSetterReal() {
 
     float expected = 3.0F;
-    Complex z = new Complex(); // à supprimer si on mutualise avec BeforeAll
+    //Complex z = new Complex(); // à supprimer si on mutualise avec BeforeAll
 
     z.setRealPart(expected);
     assertThat(z.getRealPart()).as("problem on setter real")
@@ -103,25 +104,34 @@ class ComplexTest {
 
   @Test
   void testZeroTrue() {
-    Complex z = new Complex(0.0F, 0.0F); // à supprimer si on mutualise avec BeforeAll
-    assertThat(z.isZero()).as("problem with isZero on Zero Complex number")
+    //Complex z = new Complex(0.0F, 0.0F); // à supprimer si on mutualise avec BeforeAll
+    //assertThat(z.isZero()).as("problem with isZero on Zero Complex number")
+      //      .isTrue();
+    Complex complexx = new Complex(0.0000000001F, 0.0F);
+    assertThat(complexx.isZero()).as("problem with isZero on Zero Complex number")
             .isTrue();
-    /*assertThat(!z.isZero()).as("problem with isZero on Zero Complex number") // à décommenter si on mutualise avec BeforeAll
-            .isTrue();*/
+    Complex complexxx = new Complex(0.0F, 0.0000000001F);
+    assertThat(complexxx.isZero()).as("problem with isZero on Zero Complex number")
+            .isTrue();
+    Complex zeroo = new Complex(0.0F, 0.0F); // à décommenter si on mutualise avec BeforeAll
+    assertThat(zeroo.isZero()).as("problem with isZero on Zero Complex number") // à décommenter si on mutualise avec BeforeAll
+            .isTrue();
+    //assertThat(zeroo.isZero()).as("problem with isZero on Zero Complex number").isTrue(); // à décommenter si on mutualise avec BeforeAll
+    assertThat(!z.isZero()).as("problem with isZero on Zero Complex number").isTrue();
 
   }
 
   @Test
   void testZeroFalse() {
-    Complex z = new Complex(1.0F, 1.0F); // à supprimer si on mutualise avec BeforeAll
+    //Complex z = new Complex(1.0F, 1.0F); // à supprimer si on mutualise avec BeforeAll
     assertThat(z.isZero()).as("problem with isZero on non Zero Complex number")
             .isFalse();
   }
 
   @Test
   void testSumReal() {
-    Complex z1 = new Complex(1.0F, 2.0F); // à supprimer si on mutualise avec BeforeAll
-    Complex z2 = new Complex(3.0F, 4.0F); // à supprimer si on mutualise avec BeforeAll
+    //Complex z1 = new Complex(1.0F, 2.0F); // à supprimer si on mutualise avec BeforeAll
+    //Complex z2 = new Complex(3.0F, 4.0F); // à supprimer si on mutualise avec BeforeAll
 
     float expected = 1.0F + 3.0F;
 
@@ -132,8 +142,8 @@ class ComplexTest {
 
   @Test
   void testSumImaginary() {
-    Complex z1 = new Complex(1.0F, 2.0F); // à supprimer si on mutualise avec BeforeAll
-    Complex z2 = new Complex(3.0F, 4.0F); // à supprimer si on mutualise avec BeforeAll
+    //Complex z1 = new Complex(1.0F, 2.0F); // à supprimer si on mutualise avec BeforeAll
+    //Complex z2 = new Complex(3.0F, 4.0F); // à supprimer si on mutualise avec BeforeAll
 
     float expected = 2.0F + 4.0F;
     Complex z = z1.sum(z2);
@@ -145,8 +155,8 @@ class ComplexTest {
 
   @Test
   void testProductReal() {
-    Complex z1 = new Complex(1.0F, 2.0F); // à supprimer si on mutualise avec BeforeAll
-    Complex z2 = new Complex(3.0F, 4.0F); // à supprimer si on mutualise avec BeforeAll
+   // Complex z1 = new Complex(1.0F, 2.0F); // à supprimer si on mutualise avec BeforeAll
+    //Complex z2 = new Complex(3.0F, 4.0F); // à supprimer si on mutualise avec BeforeAll
 
     float expected = 1.0F * 3.0F - 2.0F * 4.0F;
 
@@ -167,32 +177,30 @@ class ComplexTest {
 /**
  * A décommenter si on mutualise avec BeforeAll
  */
-    /*Complex z3 = z1.product(z2);
+    Complex z3 = z1.product(z2);
     assertThat(z3.getImaginaryPart()).as("problem with imaginary part of Product")
             .isCloseTo(expected, within(EPSILON));
 
-     */
-    Complex z = z1.product(z2); // à supprimer si on mutualise avec BeforeAll
-    assertThat(z.getImaginaryPart()).as("problem with imaginary part of Product") // à supprimer si on mutualise avec BeforeAll
-            .isCloseTo(expected, within(EPSILON));  // à supprimer si on mutualise avec BeforeAll
+
+    //Complex z = z1.product(z2); // à supprimer si on mutualise avec BeforeAll
+    //assertThat(z.getImaginaryPart()).as("problem with imaginary part of Product") // à supprimer si on mutualise avec BeforeAll
+     //       .isCloseTo(expected, within(EPSILON));  // à supprimer si on mutualise avec BeforeAll
 
 
 
   }
 
   //@Disabled
-  @Test
+  /*@Test
   final void testTimeoutInfinite() {
-    Complex.infinite();
-    fail("NYI");
-    //    assertTimeoutPreemptively(java.time.Duration.ofMillis(100), Complex::infinite);
-  }
+    assertTimeoutPreemptively(java.time.Duration.ofMillis(100), Complex::infinite);
+  }*/
 
 
   /**
    * A décommenter si on mutualise avec BeforeAll et pour tester la méthode inverse
    */
-   /*
+
   @Test
   void testIsRealPartOfInverseIsCorrect(){
     Complex inverse = z.inverse();
@@ -221,5 +229,10 @@ class ComplexTest {
     }
   }
 
-    */
+  @Test
+    void testToString(){
+        assertThat(z.toString()).isEqualTo("1.0+i2.0");// Couvre les instructions de la méthode toString
+    }
+
+
 }