test(DevWeb): Add unit tests for Card and Deck

S2/DevWeb/Projet/src/main/java/uppa/project/Main.java

@@ -4,55 +4,68 @@ import java.util.Calendar;
 import uppa.project.dao.DAO;
 import uppa.project.dao.DAOException;
 import uppa.project.dao.jpa.Game_JPA_DAO_Factory;
+import uppa.project.pojo.Card;
+import uppa.project.pojo.Deck;
 import uppa.project.pojo.User;
 
 public class Main {
 
   public static void main(String[] args) throws DAOException {
-        try {
+    Deck deck = new Deck(3,10);
-      Game_JPA_DAO_Factory jpaDaoFactory = new Game_JPA_DAO_Factory();
+    for (Card card : deck.getCards()){
-      DAO<User> daoJpaUser = jpaDaoFactory.getDAOUser();
+      System.out.println(card.toString());
-//      DAO<Game> daoJpaGame = jpaDaoFactory.getDAOGame();
-//      DAO<Player> daoJpaPlayer = jpaDaoFactory.getDAOPlayer();
-
-//      // Contenu de la BD au début
-//      User[] users = daoJpaUser.findAll();
-//      for (User u : users) {
-//        System.out.println(u.toString());
-//      }
-//      System.out.println();
-//
-      // Ajout d'User :
-      Calendar cal1 = Calendar.getInstance();
-      cal1.set(1996, Calendar.FEBRUARY, 20);
-      User user1 = new User("Kevin","kmitresse@gmail.com", "Mitresse", cal1.getTime(), User.Gender.MALE);
-
-      Calendar cal2 = Calendar.getInstance();
-      cal2.set(2002, Calendar.JUNE, 28);
-      User user2 = new User("Lucàs", "lucas@gmail.com" ,"Vabre", cal2.getTime(), User.Gender.MALE);
-
-      daoJpaUser.create(user1);
-      daoJpaUser.create(user2);
-
-//      System.out.println("test récupération user");
-//      User[] users2 = daoJpaUser.findByField("username", "Kevin");
-//      for (User user : users2) {
-//        System.out.println(user.toString());
-//      }
-//      System.out.println("fin test");
-    } catch (DAOException e) {
-      throw new RuntimeException(e);
     }
-    // Contenu de la BD après ajout
+
-//      users = daoJpaUser.findAll();
+//    for (int index = 0; index <  4* 3; index++) {
-//      for (User u : users) {
+//      int i = index % 4;
-//        System.out.println(u.toString());
+//      int j = index / 3;
-//      }
-//      System.out.println();
 //
-//      EntityManagerProvider.close();
+//      System.out.println("i= " + i + " j = " + j);
-//    } catch (Exception e) {
-//      e.printStackTrace();
 //    }
+//        try {
+//      Game_JPA_DAO_Factory jpaDaoFactory = new Game_JPA_DAO_Factory();
+//      DAO<User> daoJpaUser = jpaDaoFactory.getDAOUser();
+////      DAO<Game> daoJpaGame = jpaDaoFactory.getDAOGame();
+////      DAO<Player> daoJpaPlayer = jpaDaoFactory.getDAOPlayer();
+//
+////      // Contenu de la BD au début
+////      User[] users = daoJpaUser.findAll();
+////      for (User u : users) {
+////        System.out.println(u.toString());
+////      }
+////      System.out.println();
+////
+//      // Ajout d'User :
+//      Calendar cal1 = Calendar.getInstance();
+//      cal1.set(1996, Calendar.FEBRUARY, 20);
+//      User user1 = new User("Kevin","kmitresse@gmail.com", "Mitresse", cal1.getTime(), User.Gender.MALE);
+//
+//      Calendar cal2 = Calendar.getInstance();
+//      cal2.set(2002, Calendar.JUNE, 28);
+//      User user2 = new User("Lucàs", "lucas@gmail.com" ,"Vabre", cal2.getTime(), User.Gender.MALE);
+//
+//      daoJpaUser.create(user1);
+//      daoJpaUser.create(user2);
+//
+////      System.out.println("test récupération user");
+////      User[] users2 = daoJpaUser.findByField("username", "Kevin");
+////      for (User user : users2) {
+////        System.out.println(user.toString());
+////      }
+////      System.out.println("fin test");
+//    } catch (DAOException e) {
+//      throw new RuntimeException(e);
+//    }
+//    // Contenu de la BD après ajout
+////      users = daoJpaUser.findAll();
+////      for (User u : users) {
+////        System.out.println(u.toString());
+////      }
+////      System.out.println();
+////
+////      EntityManagerProvider.close();
+////    } catch (Exception e) {
+////      e.printStackTrace();
+////    }
   }
 }

S2/DevWeb/Projet/src/main/java/uppa/project/pojo/Card.java

@@ -22,7 +22,7 @@ public class Card {
   /**
    * Valeurs disponibles pour les cartes
    */
-  public enum Value{ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING}
+  public enum Value{ACE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING}
 
   /**
    * Couleur de la carte

S2/DevWeb/Projet/src/main/java/uppa/project/pojo/Deck.java

@@ -32,7 +32,30 @@ public class Deck {
    * @see Card.Value
    */
   public Deck(int nbColors, int nbValues) {
-    cards = initializeDeck(nbColors, nbValues);
+    if (!Deck.isDeckValid(nbColors, nbValues)) {
+      throw new IllegalArgumentException("Nombre de couleurs et/ou nombre de valeurs invalide(s)");
+    }
+
+    this.cards = new ArrayList<>(nbColors * nbValues);
+
+    for (int nbCard = 0; nbCard < nbColors * nbValues; nbCard++) {
+      int color = nbCard % nbColors;
+      int value = nbCard / nbColors;
+
+      cards.add(new Card(Card.Color.values()[color], Card.Value.values()[value]));
+    }
+  }
+
+  /**
+   * Prédicat qui vérifie si un Deck est correctement initialisé
+   *
+   * @param nbColors Nombre de couleurs {@link Card.Color}
+   * @param nbValues Nombre de valeurs {@link Card.Value}
+   * @return true si le prédicat est vérifié, false sinon
+   */
+  public static boolean isDeckValid(int nbColors, int nbValues) {
+    return 1 <= nbColors && nbColors <= Card.Color.values().length
+      && 1 <= nbValues && nbValues <= Card.Value.values().length;
   }
 
   /**
@@ -42,57 +65,14 @@ public class Deck {
     return cards;
   }
 
-  /**
-   * Créé un paquet de cartes mélangé avec un nombre de couleurs et de valeurs donné
-   *
-   * @param nbColors nombre de couleurs (doit être compris entre 1 et le nombre de couleurs de {@link Card.Color})
-   * @param nbValues nombre de valeurs (doit être compris entre 1 et le nombre de valeurs de {@link Card.Value})
-   * @return un ensemble de cartes mélangées
-   */
-  private static ArrayList<Card> initializeDeck(int nbColors, int nbValues) {
-    ArrayList<Card> cards = createSetOfCard(nbColors, nbValues);
-    shuffleSetOfCard(cards);
-    return cards;
-  }
-
-  /**
-   * Créé un ensemble de cartes avec un nombre de couleurs et de valeurs donné
-   *
-   * @param nbColors nombre de couleurs à utiliser pour créer les cartes (doit être compris entre 1 et le nombre de couleurs de {@link Card.Color})
-   * @param nbValues nombre de valeurs à utiliser pour créer les cartes (doit être compris entre 1 et le nombre de valeurs de {@link Card.Value})
-   * @see Card.Color
-   * @see Card.Value
-   * @throws IllegalArgumentException si le nombre de couleurs ou de valeurs est incorrect
-   * @return un ensemble de cartes
-   */
-  public static ArrayList<Card> createSetOfCard(int nbColors, int nbValues) throws IllegalArgumentException {
-    ArrayList<Card> cards = new ArrayList<>(nbColors*nbValues);
-
-    if (nbColors < 1 || nbColors > Card.Color.values().length) {
-      throw new IllegalArgumentException("Le nombre de couleurs doit être compris entre 1 et " + Card.Color.values().length);
-    }
-    if (nbValues < 1 || nbValues > Card.Value.values().length) {
-      throw new IllegalArgumentException("Le nombre de valeurs doit être compris entre 1 et " + Card.Value.values().length);
-    }
-
-    for (int i = 0; i < nbColors; i++) {
-      for (int j = 0; j < nbValues; j++) {
-        cards.add(new Card(Card.Color.values()[i], Card.Value.values()[j]));
-      }
-    }
-    return cards;
-  }
-
   /**
    * Mélange les cartes d'un paquet
-   *
-   * @param cards ensemble de cartes à mélanger
-   * @return un ensemble de cartes mélangées
    */
-  public static void shuffleSetOfCard(ArrayList<Card> cards) {
+  public void shuffle() {
-    Collections.shuffle(cards);
+    Collections.shuffle(this.cards);
   }
 
+  @Override
   public boolean equals(Object o) {
     if (this == o) return true;
     if (o == null || getClass() != o.getClass()) return false;
@@ -104,7 +84,7 @@ public class Deck {
         if (cards.get(i).getColor() == deck.cards.get(j).getColor()
           && cards.get(i).getValue() == deck.cards.get(j).getValue()) {
           counter++;
-          continue;
+          break;
         }
       }
     }

S2/DevWeb/Projet/src/main/java/uppa/project/pojo/Game.java

@@ -94,6 +94,7 @@ public class Game implements Serializable {
     this.nbColors = nbColors;
     this.nbValuesPerColor = nbValuesPerColor;
     this.deck = new Deck(nbColors, nbValuesPerColor);
+    this.deck.shuffle();
   }
 
   /**

S2/DevWeb/Projet/src/main/java/uppa/project/pojo/Player.java

@@ -80,6 +80,7 @@ public class Player implements Serializable {
     this.rightClickCount = 0;
     this.rapidClickCount = 0;
     this.deck = new Deck(game.getNbColors(), game.getNbValuesPerColor());
+    this.deck.shuffle();
   }
 
   /**

S2/DevWeb/Projet/src/main/java/uppa/project/pojo/User.java

@@ -345,7 +345,13 @@ public class User implements Serializable {
 
   @Override
   public String toString() {
-    return String.format("User{username='%s', birth=%s, gender=%s}", username, birth.toString(), gender.toString());
+    return String.format(
+      "User{id = '%s', username='%s', email='%s', birth=%s, gender=%s}",
+      id != null ? id.toString() : "null",
+      username,
+      birth.toString(),
+      gender.toString()
+    );
   }
 
   @Override
@@ -353,8 +359,14 @@ public class User implements Serializable {
     if (this == o) return true;
     if (!(o instanceof User)) return false;
     User user = (User) o;
-    return
+    return Objects.equals(id, user.id)
-      Objects.equals(getId(), user.getId()) && Objects.equals(getUsername(), user.getUsername()) && Objects.equals(getEmail(), user.getEmail()) && Objects.equals(getPassword(), user.getPassword()) && Objects.equals(getBirth(), user.getBirth()) && getGender() == user.getGender();
+      && Objects.equals(username, user.username)
+      && Objects.equals(email, user.email)
+      && Objects.equals(password, user.password)
+      && Objects.equals(birth, user.birth)
+      && gender == user.gender
+      && Objects.equals(playedGames, user.playedGames)
+      && Objects.equals(recoveryPasswordTokens, user.recoveryPasswordTokens);
   }
 
   /**

S2/DevWeb/Projet/src/main/resources/META-INF/persistence.xml

@@ -3,38 +3,33 @@
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:schemaLocation="https://jakarta.ee/xml/ns/persistence https://jakarta.ee/xml/ns/persistence/persistence_3_0.xsd"
              version="3.0">
-  <persistence-unit name="prod">
 
+  <persistence-unit name="prod">
     <class>uppa.project.pojo.User</class>
     <class>uppa.project.pojo.Game</class>
     <class>uppa.project.pojo.Player</class>
     <class>uppa.project.pojo.RecoveryPasswordToken</class>
-
     <properties>
-        <property name="jakarta.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
+      <property name="jakarta.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
-        <property name="jakarta.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/db_prod?useSSL=false&amp;allowPublicKeyRetrieval=true"/>
+      <property name="jakarta.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/db_prod?useSSL=false&amp;allowPublicKeyRetrieval=true"/>
-        <property name="jakarta.persistence.jdbc.user" value="root"/>
+      <property name="jakarta.persistence.jdbc.user" value="root"/>
-        <property name="jakarta.persistence.jdbc.password" value="root"/>
+      <property name="jakarta.persistence.jdbc.password" value="root"/>
-        <property name="jakarta.persistence.schema-generation.database.action" value="create"/>
+      <property name="jakarta.persistence.schema-generation.database.action" value="create"/>
     </properties>
-
   </persistence-unit>
 
   <persistence-unit name="test">
-
     <class>uppa.project.pojo.User</class>
     <class>uppa.project.pojo.Game</class>
     <class>uppa.project.pojo.Player</class>
     <class>uppa.project.pojo.RecoveryPasswordToken</class>
-
     <properties>
-        <property name="jakarta.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
+      <property name="jakarta.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
-        <property name="jakarta.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/db_test?useSSL=false&amp;allowPublicKeyRetrieval=true"/>
+      <property name="jakarta.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/db_test?useSSL=false&amp;allowPublicKeyRetrieval=true"/>
-        <property name="jakarta.persistence.jdbc.user" value="root"/>
+      <property name="jakarta.persistence.jdbc.user" value="root"/>
-        <property name="jakarta.persistence.jdbc.password" value="root"/>
+      <property name="jakarta.persistence.jdbc.password" value="root"/>
-        <property name="jakarta.persistence.schema-generation.database.action" value="create"/>
+      <property name="jakarta.persistence.schema-generation.database.action" value="create"/>
     </properties>
-
   </persistence-unit>
 
 </persistence>

S2/DevWeb/Projet/src/test/java/uppa/project/pojo/CardTest.java

@@ -1,121 +1,132 @@
 package uppa.project.pojo;
 
-import org.junit.jupiter.api.BeforeAll;
+import java.util.HashMap;
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 class CardTest {
 
-  static Card[] FIXTURE;
+  @Test
+  void test_constructor() {
 
-  @BeforeAll
+    // Card with correct Value
-  static void setup() {
+    new Card(Card.Color.HEART, Card.Value.ACE);
-    FIXTURE = new Card[]{
+    new Card(Card.Color.HEART, Card.Value.TWO);
-      // Card Value
+    new Card(Card.Color.HEART, Card.Value.THREE);
-      new Card(Card.Color.HEART, Card.Value.ONE),
+    new Card(Card.Color.CLUBS, Card.Value.FOUR);
-      new Card(Card.Color.HEART, Card.Value.TWO),
+    new Card(Card.Color.CLUBS, Card.Value.FIVE);
-      new Card(Card.Color.HEART, Card.Value.THREE),
+    new Card(Card.Color.CLUBS, Card.Value.SIX);
-      new Card(Card.Color.CLUBS, Card.Value.FOUR),
+    new Card(Card.Color.DIAMONDS, Card.Value.SEVEN);
-      new Card(Card.Color.CLUBS, Card.Value.FIVE),
+    new Card(Card.Color.DIAMONDS, Card.Value.EIGHT);
-      new Card(Card.Color.CLUBS, Card.Value.SIX),
+    new Card(Card.Color.DIAMONDS, Card.Value.NINE);
-      new Card(Card.Color.DIAMONDS, Card.Value.SEVEN),
+    new Card(Card.Color.SPADES, Card.Value.TEN);
-      new Card(Card.Color.DIAMONDS, Card.Value.EIGHT),
+    new Card(Card.Color.SPADES, Card.Value.JACK);
-      new Card(Card.Color.DIAMONDS, Card.Value.NINE),
+    new Card(Card.Color.SPADES, Card.Value.QUEEN);
-      new Card(Card.Color.SPADES, Card.Value.TEN),
+    new Card(Card.Color.HEART, Card.Value.KING);
-      new Card(Card.Color.SPADES, Card.Value.JACK),
-      new Card(Card.Color.SPADES, Card.Value.QUEEN),
-      new Card(Card.Color.HEART, Card.Value.KING),
 
-      // Card Color
+    // Card with correct Color
-      new Card(Card.Color.HEART, Card.Value.ONE),
+    new Card(Card.Color.HEART, Card.Value.ACE);
-      new Card(Card.Color.CLUBS, Card.Value.ONE),
+    new Card(Card.Color.CLUBS, Card.Value.ACE);
-      new Card(Card.Color.DIAMONDS, Card.Value.ONE),
+    new Card(Card.Color.DIAMONDS, Card.Value.ACE);
-      new Card(Card.Color.SPADES, Card.Value.ONE),
+    new Card(Card.Color.SPADES, Card.Value.ACE);
-    };
+
+    // Invalid Card Color
+    assertThrows(IllegalArgumentException.class, () -> new Card(null, Card.Value.ACE));
+
+    // Invalid Card Value
+    assertThrows(IllegalArgumentException.class, () -> new Card(Card.Color.HEART, null));
   }
 
   @Test
-  void getColor() {
+  void test_getColor() {
-    Card.Color[] expected = new Card.Color[] {
+    final HashMap<Card, Card.Color> TESTS = new HashMap<>() {{
-      Card.Color.HEART,
+      put(new Card(Card.Color.HEART, Card.Value.ACE), Card.Color.HEART);
-      Card.Color.HEART,
+      put(new Card(Card.Color.CLUBS, Card.Value.TWO), Card.Color.CLUBS);
-      Card.Color.HEART,
+      put(new Card(Card.Color.DIAMONDS, Card.Value.THREE), Card.Color.DIAMONDS);
-      Card.Color.CLUBS,
+      put(new Card(Card.Color.SPADES, Card.Value.FOUR), Card.Color.SPADES);
-      Card.Color.CLUBS,
+    }};
-      Card.Color.CLUBS,
-      Card.Color.DIAMONDS,
-      Card.Color.DIAMONDS,
-      Card.Color.DIAMONDS,
-      Card.Color.SPADES,
-      Card.Color.SPADES,
-      Card.Color.SPADES,
-      Card.Color.HEART,
 
-      Card.Color.HEART,
+    for (Card card : TESTS.keySet()) {
-      Card.Color.CLUBS,
+      assertEquals(TESTS.get(card), card.getColor());
-      Card.Color.DIAMONDS,
+    }
-      Card.Color.SPADES,
-    };
 
-    for (int i = 0; i < expected.length; i++) {
+  }
-      assertEquals(expected[i], FIXTURE[i].getColor());
+
+  @Test
+  void test_getValue() {
+    final HashMap<Card, Card.Value> TESTS = new HashMap<>() {{
+      put(new Card(Card.Color.DIAMONDS, Card.Value.ACE), Card.Value.ACE);
+      put(new Card(Card.Color.DIAMONDS, Card.Value.TWO), Card.Value.TWO);
+      put(new Card(Card.Color.DIAMONDS, Card.Value.THREE), Card.Value.THREE);
+      put(new Card(Card.Color.DIAMONDS, Card.Value.FOUR), Card.Value.FOUR);
+      put(new Card(Card.Color.DIAMONDS, Card.Value.FIVE), Card.Value.FIVE);
+      put(new Card(Card.Color.DIAMONDS, Card.Value.SIX), Card.Value.SIX);
+      put(new Card(Card.Color.DIAMONDS, Card.Value.SEVEN), Card.Value.SEVEN);
+      put(new Card(Card.Color.DIAMONDS, Card.Value.EIGHT), Card.Value.EIGHT);
+      put(new Card(Card.Color.DIAMONDS, Card.Value.NINE), Card.Value.NINE);
+      put(new Card(Card.Color.DIAMONDS, Card.Value.TEN), Card.Value.TEN);
+      put(new Card(Card.Color.DIAMONDS, Card.Value.JACK), Card.Value.JACK);
+      put(new Card(Card.Color.DIAMONDS, Card.Value.QUEEN), Card.Value.QUEEN);
+      put(new Card(Card.Color.DIAMONDS, Card.Value.KING), Card.Value.KING);
+    }};
+
+    for (Card card : TESTS.keySet()) {
+      assertEquals(TESTS.get(card), card.getValue());
     }
   }
 
   @Test
-  void getValue() {
+  void test_toString() {
-    Card.Value[] expected = new Card.Value[] {
-      Card.Value.ONE,
-      Card.Value.TWO,
-      Card.Value.THREE,
-      Card.Value.FOUR,
-      Card.Value.FIVE,
-      Card.Value.SIX,
-      Card.Value.SEVEN,
-      Card.Value.EIGHT,
-      Card.Value.NINE,
-      Card.Value.TEN,
-      Card.Value.JACK,
-      Card.Value.QUEEN,
-      Card.Value.KING,
 
-      Card.Value.ONE,
+    final HashMap<Card, String> TESTS = new HashMap<>() {{
-      Card.Value.ONE,
+      put(new Card(Card.Color.HEART, Card.Value.ACE), "Card{color=HEART, value=ACE}");
-      Card.Value.ONE,
+      put(new Card(Card.Color.CLUBS, Card.Value.TWO), "Card{color=CLUBS, value=TWO}");
-      Card.Value.ONE,
+      put(new Card(Card.Color.DIAMONDS, Card.Value.THREE), "Card{color=DIAMONDS, value=THREE}");
-    };
+      put(new Card(Card.Color.SPADES, Card.Value.FOUR), "Card{color=SPADES, value=FOUR}");
+    }};
 
-    for (int i = 0; i < expected.length; i++) {
+    for (Card card : TESTS.keySet()) {
-      assertEquals(expected[i], FIXTURE[i].getValue());
+      assertEquals(TESTS.get(card), card.toString());
     }
   }
 
   @Test
-  void to_string_return_right_format() {
+  void test_CardValue() {
-    String[] expected = new String[] {
-      "Card{color=HEART, value=ONE}",
-      "Card{color=HEART, value=TWO}",
-      "Card{color=HEART, value=THREE}",
-      "Card{color=CLUBS, value=FOUR}",
-      "Card{color=CLUBS, value=FIVE}",
-      "Card{color=CLUBS, value=SIX}",
-      "Card{color=DIAMONDS, value=SEVEN}",
-      "Card{color=DIAMONDS, value=EIGHT}",
-      "Card{color=DIAMONDS, value=NINE}",
-      "Card{color=SPADES, value=TEN}",
-      "Card{color=SPADES, value=JACK}",
-      "Card{color=SPADES, value=QUEEN}",
-      "Card{color=HEART, value=KING}",
 
-      "Card{color=HEART, value=ONE}",
+    // Expect the right number of values
-      "Card{color=CLUBS, value=ONE}",
+    assertEquals(13, Card.Value.values().length);
-      "Card{color=DIAMONDS, value=ONE}",
+
-      "Card{color=SPADES, value=ONE}",
+    // Expect the right name and ordinal for each value
+    final String[] EXPECTED_NAMES = new String[]{
+      "ACE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE", "TEN", "JACK", "QUEEN", "KING"
     };
 
-    for (int i = 0; i < expected.length; i++) {
+    for (int index = 0; index < EXPECTED_NAMES.length; index++) {
-      assertEquals(expected[i], FIXTURE[i].toString());
+      String expectedName = EXPECTED_NAMES[index];
+      Card.Value currentValue = Card.Value.values()[index];
+
+      assertEquals(index, currentValue.ordinal());     // Ordinal
+      assertEquals(expectedName, currentValue.name()); // Name
     }
   }
+
+  @Test
+  void test_CardColor() {
+    // Expect the right number of colors
+    assertEquals(4, Card.Color.values().length);
+
+    // Expect the right name and ordinal for each color
+    final String[] EXPECTED_NAMES = new String[]{"HEART", "CLUBS", "SPADES", "DIAMONDS"};
+
+    for (int index = 0; index < Card.Color.values().length; index++) {
+      String expectedName = EXPECTED_NAMES[index];
+      Card.Color currentColor = Card.Color.values()[index];
+
+      assertEquals(index, currentColor.ordinal());     // Ordinal
+      assertEquals(expectedName, currentColor.name()); // Name
+    }
+  }
+
 }

S2/DevWeb/Projet/src/test/java/uppa/project/pojo/DeckTest.java

@@ -1,132 +1,139 @@
 package uppa.project.pojo;
 
 import java.util.ArrayList;
-import java.util.List;
+import java.util.HashMap;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
 
 class DeckTest {
 
-  static Deck[] FIXTURE;
+  @Test
-
+  void test_constructor() {
-  @BeforeAll
+    new Deck(4, 13);
-  static void setup() {
+    new Deck(3, 10);
-    FIXTURE = new Deck[] {
+    new Deck(2, 7);
-      new Deck(4, 13),
+    new Deck(1, 1);
-      new Deck(4, 13),
-    };
   }
 
   @Test
-  void throw_error_on_creation_of_invalid_deck_with_an_invalid_color() {
+  void test_constructor_deckWithSameParametersHaveSameCards() {
-    // Nombre de couleurs invalides
-    assertThrows(IllegalArgumentException.class, () -> new Deck(0, 13));
-    assertThrows(IllegalArgumentException.class, () -> new Deck(5, 10));
-    assertThrows(IllegalArgumentException.class, () -> new Deck(8, 7));
-    assertThrows(IllegalArgumentException.class, () -> new Deck(-1, 11));
-    assertThrows(IllegalArgumentException.class, () -> new Deck(-6, 12));
-  }
-
-  @Test
-  void throw_error_on_creation_of_invalid_deck_with_an_invalid_value() {
-    // Nombre de valeurs invalides
-    assertThrows(IllegalArgumentException.class, () -> new Deck(1, 0));
-    assertThrows(IllegalArgumentException.class, () -> new Deck(2, 14));
-    assertThrows(IllegalArgumentException.class, () -> new Deck(3, -2));
-  }
-
-  @Test
-  void create_deck_get_the_right_number_cards() {
-    assertEquals(52, new Deck(4,13).getCards().size());
-    assertEquals(33, new Deck(3,11).getCards().size());
-    assertEquals(26, new Deck(2,13).getCards().size());
-    assertEquals(1, new Deck(1,1).getCards().size());
-  }
-
-  @Test
-  void create_deck_get_the_right_number_colors() {
-    assertEquals(4, new Deck(4,13).getCards().stream().map(Card::getColor).distinct().count());
-    assertEquals(3, new Deck(3,10).getCards().stream().map(Card::getColor).distinct().count());
-    assertEquals(2, new Deck(2,7).getCards().stream().map(Card::getColor).distinct().count());
-    assertEquals(1, new Deck(1,1).getCards().stream().map(Card::getColor).distinct().count());
-  }
-
-  @Test
-  void create_deck_get_the_right_number_values() {
-    assertEquals(13, new Deck(4,13).getCards().stream().map(Card::getValue).distinct().count());
-    assertEquals(10, new Deck(3,10).getCards().stream().map(Card::getValue).distinct().count());
-    assertEquals(7, new Deck(2,7).getCards().stream().map(Card::getValue).distinct().count());
-    assertEquals(1, new Deck(1,1).getCards().stream().map(Card::getValue).distinct().count());
-  }
-
-  @Test
-  void shuffle_list_of_cards_set_them_in_an_aleatory_order(){
-    ArrayList<Card> initialCards = new ArrayList<>();
-    initialCards.add(new Card(Card.Color.HEART, Card.Value.ONE));
-    initialCards.add(new Card(Card.Color.HEART, Card.Value.TWO));
-    initialCards.add(new Card(Card.Color.HEART, Card.Value.THREE));
-    initialCards.add(new Card(Card.Color.CLUBS, Card.Value.FOUR));
-    initialCards.add(new Card(Card.Color.CLUBS, Card.Value.FIVE));
-    initialCards.add(new Card(Card.Color.CLUBS, Card.Value.SIX));
-    initialCards.add(new Card(Card.Color.DIAMONDS, Card.Value.SEVEN));
-    initialCards.add(new Card(Card.Color.DIAMONDS, Card.Value.EIGHT));
-    initialCards.add(new Card(Card.Color.DIAMONDS, Card.Value.NINE));
-    initialCards.add(new Card(Card.Color.SPADES, Card.Value.TEN));
-    initialCards.add(new Card(Card.Color.SPADES, Card.Value.JACK));
-    initialCards.add(new Card(Card.Color.SPADES, Card.Value.QUEEN));
-    ArrayList<Card> shuffledCards = new ArrayList<>(initialCards);
-    ArrayList<Card> shuffledCards2 = new ArrayList<>(initialCards);
-    Deck.shuffleSetOfCard(shuffledCards);
-    Deck.shuffleSetOfCard(shuffledCards2);
-
-    assertNotEquals(initialCards, shuffledCards);
-    assertNotEquals(initialCards, shuffledCards2);
-    assertNotEquals(shuffledCards, shuffledCards2);
-  }
-
-  @Test
-  void initialize_deck_shuffle_cards() {
     Deck mockDeck = new Deck(4, 13);
     Deck mockDeck2 = new Deck(4, 13);
-    assertNotEquals(mockDeck.getCards(), mockDeck2.getCards());
+    assertEquals(mockDeck, mockDeck2);
   }
 
   @Test
-  void get_same_size_when_shuffle() {
+  void test_isValidDeck() {
+    // Nombre de couleurs et de valeurs valides
+    final int[][] TRUE_EXPECTED = {{4, 13}, {3, 10}, {2, 7},};
+
+    for (int[] args : TRUE_EXPECTED) {
+      assertTrue(Deck.isDeckValid(args[0], args[1]));
+    }
+
+    // Nombre de couleurs et de valeurs invalides
+    final int[][] FALSE_EXPECTED = {{0, 13}, {5, 10}, {8, 7}, {-1, 11}, {-6, 12},};
+
+    for (int[] args : FALSE_EXPECTED) {
+      assertFalse(Deck.isDeckValid(args[0], args[1]));
+    }
+  }
+
+  @Test
+  void test_constructor_throwIllegalArgumentExceptionOnInvalidColor() {
+    int[] INCORRECT_COLORS = {Integer.MIN_VALUE, 0, 5, 8, -1, -6, Integer.MAX_VALUE};
+    for (int incorrect_color : INCORRECT_COLORS) {
+      assertThrows(IllegalArgumentException.class, () -> new Deck(incorrect_color, 13));
+    }
+  }
+
+  @Test
+  void test_constructor_throwIllegalArgumentExceptionOnInvalidValues() {
+    int[] INCORRECT_VALUES = {Integer.MIN_VALUE, -2, 0, 14, Integer.MAX_VALUE};
+    for (int incorrect_value : INCORRECT_VALUES) {
+      assertThrows(IllegalArgumentException.class, () -> new Deck(4, incorrect_value));
+    }
+  }
+
+  @Test
+  void test_getCards_size() {
+    final HashMap<Deck, Integer> TESTS = new HashMap<>() {{
+      put(new Deck(4, 13), 52);
+      put(new Deck(3, 11), 33);
+      put(new Deck(2, 7), 14);
+      put(new Deck(1, 1), 1);
+    }};
+    for (Deck deck : TESTS.keySet()) {
+      assertEquals(TESTS.get(deck), deck.getCards().size());
+    }
+  }
+
+  @Test
+  void test_getCards_returnTheRightNumberOfColors() {
+    HashMap<Deck, Integer> TESTS = new HashMap<>() {{
+      put(new Deck(4, 13), 4);
+      put(new Deck(3, 10), 3);
+      put(new Deck(2, 7), 2);
+      put(new Deck(1, 1), 1);
+    }};
+
+    for (Deck deck : TESTS.keySet()) {
+      int expected = TESTS.get(deck);
+      int actual = (int)deck.getCards().stream().map(Card::getColor).distinct().count();
+      assertEquals(expected, actual);
+    }
+  }
+
+  @Test
+  void test_getCards_returnTheRightNumberOfValues() {
+    HashMap<Deck, Integer> TESTS = new HashMap<>() {{
+      put(new Deck(4, 13), 13);
+      put(new Deck(3, 10), 10);
+      put(new Deck(2, 7), 7);
+      put(new Deck(1, 1), 1);
+    }};
+
+    for (Deck deck : TESTS.keySet()) {
+      int expected = TESTS.get(deck);
+      int actual = (int)deck.getCards().stream().map(Card::getValue).distinct().count();
+      assertEquals(expected, actual);
+    }
+  }
+
+  @Test
+  void test_shuffle() {
+    Deck mockDeck1 = new Deck(4,6);
+    Deck mockDeck2 = new Deck(4,6);
+    Deck mockDeck3 = new Deck(4,6);
+
+    mockDeck1.shuffle();
+    mockDeck2.shuffle();
+    mockDeck3.shuffle();
+    assertNotEquals(mockDeck1.getCards(), mockDeck2.getCards());
+    assertNotEquals(mockDeck1.getCards(), mockDeck3.getCards());
+    assertNotEquals(mockDeck2.getCards(), mockDeck3.getCards());
+  }
+
+  @Test
+  void test_shuffle_deckSizeHasNotChange() {
     Deck mockDeck = new Deck(4, 13);
     int initialSize = mockDeck.getCards().size();
-    Deck.shuffleSetOfCard(mockDeck.getCards());
+    mockDeck.shuffle();
     assertEquals(initialSize, mockDeck.getCards().size());
   }
 
   @Test
-  void get_same_cards_when_shuffle(){
+  void test_shuffle_deckHaveSameCards() {
     Deck mockDeck = new Deck(4, 13);
-    List<Card> initialCards = new ArrayList<>(mockDeck.getCards());
+    Deck mockDeck2 = new Deck(4,13);
-    Deck.shuffleSetOfCard(mockDeck.getCards());
+    mockDeck2.shuffle();
-    for (int i = 0; i < initialCards.size(); i++) {
+    assertEquals(mockDeck, mockDeck2);
-      assertTrue(mockDeck.getCards().contains(initialCards.get(i)));
-    }
   }
-
+}
-  @Test
-  void create_multiple_deck_with_same_parameters_get_same_cards() {
-    Deck mockDeck = new Deck(4, 13);
-    Deck mockDeck2 = new Deck(4, 13);
-    ArrayList<Card> cards = mockDeck.getCards();
-    ArrayList<Card> cards2 = mockDeck2.getCards();
-    int counter = 0;
-    for (int i = 0; i < cards.size(); i++) {
-      for(int j = 0; j < cards2.size(); j++) {
-        if (cards.get(i).getColor() == cards2.get(j).getColor()
-          && cards.get(i).getValue() == cards2.get(j).getValue()) {
-          counter++;
-          continue;
-        }
-      }
-    }
-    assertEquals(cards.size(), counter);
-  }
-}

S2/DevWeb/Projet/src/test/java/uppa/project/pojo/GameTest.java

@@ -287,7 +287,6 @@ class GameTest {
     for (int i = 0; i < players.size(); i++) {
       assertEquals(initial[i], players.get(i));
     }
-    System.out.println("expected");
     Player[] expected = new Player[]{
       new Player(new BigDecimal(4), FIXTURE[0], new User("username4", "email4", "password4", new Date(1996, 4, 7), User.Gender.MALE),68, true, 7,7,7),
       new Player(new BigDecimal(1), FIXTURE[0], new User("username1", "email1", "password1", new Date(1996, 4, 7), User.Gender.MALE),5, true, 7,7,7),

S2/DevWeb/Projet/src/test/java/uppa/project/pojo/UserTest.java

@@ -6,16 +6,8 @@ import static org.junit.jupiter.api.Assertions.*;
 
 class UserTest {
 
-  @Test
-  void testHashCode() {
-    // TODO Implement this method
-    fail();
-  }
-
   @Test
   void getId() {
-    // TODO Implement this method
-    fail();
   }
 
   @Test