kmitresse/cards-rush
1
0
Fork 0
mirror of https://github.com/kmitresse/Cards-Rush.git synced 2026-07-09 13:27:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

test(DevWeb): Edit tests in PlayerTest

Browse Source
This commit is contained in:
Lucàs
2024-03-28 02:27:11 +01:00
parent 3dfdd195b1
commit 9613e62a78
2 changed files with 184 additions and 232 deletions
Download Patch File Download Diff File Expand all files Collapse all files
S2/DevWeb/Projet/src/main/java/uppa/project/pojo/Player.java
+4 -1
View File
@@ -102,6 +102,9 @@ public class Player implements Serializable {
this.clickCount = clickCount; this.clickCount = clickCount;
this.rightClickCount = rightClickCount; this.rightClickCount = rightClickCount;
this.rapidClickCount = rapidClickCount; this.rapidClickCount = rapidClickCount;
this.deck = new Deck(game.getNbColors(), game.getNbValuesPerColor());
this.deck.shuffle();
} }
@Override @Override
@@ -162,7 +165,7 @@ public class Player implements Serializable {
* *
* @param points les points à ajouter * @param points les points à ajouter
*/ */
public void updateScore(int points) { this.score += points; } public void addToScore(int points) { this.score += points; }
/** /**
* @return si le joueur est gagnant * @return si le joueur est gagnant
S2/DevWeb/Projet/src/test/java/uppa/project/pojo/PlayerTest.java
+173 -224
View File
@@ -3,12 +3,46 @@ package uppa.project.pojo;
import java.math.BigDecimal; import java.math.BigDecimal;
import java.util.Date; import java.util.Date;
import java.util.HashMap; import java.util.HashMap;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*; import static org.junit.jupiter.api.Assertions.*;
class PlayerTest { class PlayerTest {
static Player[] fixture;
@BeforeEach
void beforeEach() {
fixture = new Player[]{
new Player(
new BigDecimal(1),
new Game(new BigDecimal(1), new Date(101, 2, 4), Game.Difficulty.EASY,18,2,10,null),
new User("username1", "email1", "password1", new Date(), User.Gender.MALE),
10, true, 6,5,5
),
new Player(
new BigDecimal(2),
new Game(new BigDecimal(2), new Date(101, 2, 4), Game.Difficulty.EASY,18,4,13,null),
new User("username2", "email2", "password2", new Date(), User.Gender.FEMALE),
20, false, 4,2,1
),
new Player(
new BigDecimal(3),
new Game(new BigDecimal(3), new Date(101, 2, 4), Game.Difficulty.EASY,18,3,6,null),
new User("username3", "email3", "password3", new Date(), User.Gender.OTHER),
15, true, 10,5,5
),
new Player(
new BigDecimal(4),
new Game(new BigDecimal(4), new Date(101, 2, 4), Game.Difficulty.HARD,18,3,6,null),
new User("username4", "email4", "password4",
new Date(100, 1, 1), User.Gender.OTHER),
15, true, 10,5,5
)
};
}
@Test @Test
void test_constructor() { void test_constructor() {
@@ -16,254 +50,200 @@ class PlayerTest {
new Player(new Game(Game.Difficulty.EASY,4,2,3), new User()); new Player(new Game(Game.Difficulty.EASY,4,2,3), new User());
new Player(new Game(Game.Difficulty.EASY,4,2,3), new User()); new Player(new Game(Game.Difficulty.EASY,4,2,3), new User());
new Player(new Game(Game.Difficulty.EASY,4,2,3), new User()); new Player(new Game(Game.Difficulty.EASY,4,2,3), new User());
new Player(new BigDecimal(1), new Game(), new User(),45, true, 15, 20, 6);
} }
@Test @Test
void get_game() { void test_getGame() {
Game[] games = new Game[]{ Game[] games = new Game[]{
new Game(new BigDecimal(1), new Date(), Game.Difficulty.EASY,20,4,5,null), new Game(new BigDecimal(1), new Date(101, 2, 4), Game.Difficulty.EASY,18,2,10,null),
new Game(new BigDecimal(2), new Date(), Game.Difficulty.EASY,20,4,5,null), new Game(new BigDecimal(2), new Date(101, 2, 4), Game.Difficulty.EASY,18,4,13,null),
new Game(new BigDecimal(3), new Date(), Game.Difficulty.EASY,20,4,5,null), new Game(new BigDecimal(3), new Date(101, 2, 4), Game.Difficulty.EASY,18,3,6,null),
}; };
final HashMap<Player, Game> TESTS = new HashMap<>() {{ final HashMap<Player, Game> TESTS = new HashMap<>() {{
put(new Player(games[0], new User()), games[0]); put(fixture[0], games[0]);
put(new Player(games[1], new User()), games[1]); put(fixture[1], games[1]);
put(new Player(games[2], new User()), games[2]); put(fixture[2], games[2]);
}}; }};
for (Player player : TESTS.keySet()) { for (Player player : TESTS.keySet()) {
assertEquals(TESTS.get(player), player.getGame()); assertEquals(TESTS.get(player), player.getGame());
} }
} }
@Test @Test
void set_game() { void test_setGame() {
Game[] games = new Game[]{ Player player = fixture[0];
new Game(new BigDecimal(1), new Date(), Game.Difficulty.EASY,20,4,5,null), Game game = player.getGame();
new Game(new BigDecimal(2), new Date(), Game.Difficulty.EASY,20,4,5,null),
new Game(new BigDecimal(3), new Date(), Game.Difficulty.EASY,20,4,5,null),
};
Game game =
new Game(new BigDecimal(4), new Date(), Game.Difficulty.HARD,20,4,5,null);
final HashMap<Player, Game> TESTS = new HashMap<>() {{ // Set a new game
put(new Player(games[0], new User()), game); Game newGame = new Game(new BigDecimal(4), new Date(), Game.Difficulty.HARD,20,4,5,null);
put(new Player(games[1], new User()), game); player.setGame(newGame);
put(new Player(games[2], new User()), game);
}}; assertNotEquals(game, player.getGame());
for (Player player : TESTS.keySet()) { assertEquals(newGame, player.getGame());
Game expected = TESTS.get(player);
player.setGame(game);
assertEquals(expected, player.getGame());
}
} }
@Test @Test
void get_user() { void test_getUser() {
Game[] games = new Game[]{ Player player = fixture[0];
new Game(new BigDecimal(1), new Date(), Game.Difficulty.EASY,20,4,5,null),
new Game(new BigDecimal(2), new Date(), Game.Difficulty.EASY,20,4,5,null),
new Game(new BigDecimal(3), new Date(), Game.Difficulty.EASY,20,4,5,null),
};
User[] users = new User[]{
new User("username1", "email1", "password1", new Date(), User.Gender.MALE),
new User("username2", "email2", "password2", new Date(), User.Gender.FEMALE),
new User("username3", "email3", "password3", new Date(), User.Gender.OTHER),
};
final HashMap<Player, User> TESTS = new HashMap<>() {{ User expected = new User("username1", "email1", "password1", new Date(), User.Gender.MALE);
put(new Player(games[0], users[0]), users[0]); assertEquals(expected.getUsername(), player.getUser().getUsername());
put(new Player(games[1], users[1]), users[1]); assertEquals(expected.getEmail(), player.getUser().getEmail());
put(new Player(games[2], users[2]), users[2]); assertEquals(expected.getPassword(), player.getUser().getPassword());
}}; assertEquals(expected.getGender(), player.getUser().getGender());
for (Player player : TESTS.keySet()) {
assertEquals(TESTS.get(player), player.getUser());
}
} }
@Test @Test
void set_user() { void test_setUser() {
Game[] games = new Game[]{ Player player = fixture[0];
new Game(new BigDecimal(1), new Date(), Game.Difficulty.EASY,20,4,5,null), User user = player.getUser();
new Game(new BigDecimal(2), new Date(), Game.Difficulty.EASY,20,4,5,null),
new Game(new BigDecimal(3), new Date(), Game.Difficulty.EASY,20,4,5,null),
};
User[] users = new User[]{
new User("username1", "email1", "password1", new Date(), User.Gender.MALE),
new User("username2", "email2", "password2", new Date(), User.Gender.FEMALE),
new User("username3", "email3", "password3", new Date(), User.Gender.OTHER),
};
User user = new User("username000", "email000", "password000", new Date(), User.Gender.OTHER);
final HashMap<Player, User> TESTS = new HashMap<>() {{ // Set a new user
put(new Player(games[0], users[0]), user); User newUser = new User("username2", "email2", "password2", new Date(), User.Gender.FEMALE);
put(new Player(games[1], users[1]), user); player.setUser(newUser);
put(new Player(games[2], users[2]), user);
}}; assertNotEquals(user, player.getUser());
for (Player player : TESTS.keySet()) { assertEquals(newUser, player.getUser());
User expected =TESTS.get(player);
player.setUser(user);
assertEquals(expected, player.getUser());
}
} }
@Test @Test
void get_score() { void test_getScore() {
final HashMap<Player, Integer> TESTS = new HashMap<>() {{ final HashMap<Player, Integer> TESTS = new HashMap<>() {{
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 5,5,5),10); put(fixture[0],10);
put(new Player(new BigDecimal(2), new Game(), new User(), 20, true, 5,5,5),20); put(fixture[1],20);
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 5,5,5),15);; put(fixture[2],15);;
}}; }};
for (Player player : TESTS.keySet()) { for (Player player : TESTS.keySet()) {
assertEquals(TESTS.get(player), player.getScore()); assertEquals(TESTS.get(player), player.getScore());
} }
} }
@Test @Test
void set_score() { void test_setScore() {
final HashMap<Player, Integer> TESTS = new HashMap<>() {{ Player player = fixture[0];
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 5,5,5),50); int score = player.getScore();
put(new Player(new BigDecimal(2), new Game(), new User(), 20, true, 5,5,5),50);
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 5,5,5),50); // Set a new score
}}; player.setScore(15);
for (Player player : TESTS.keySet()) { assertEquals(15, player.getScore());
int expected = TESTS.get(player); assertNotEquals(score, player.getScore());
player.setScore(50);
assertEquals(expected, player.getScore());
}
} }
@Test @Test
void update_score() { void test_addToScore() {
final HashMap<Player, Integer> TESTS = new HashMap<>() {{ Player player = fixture[0];
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 5,5,5),13); int score = player.getScore();
put(new Player(new BigDecimal(2), new Game(), new User(), 20, true, 5,5,5),23);
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 5,5,5),18); // Update the score
}}; player.addToScore(5);
for (Player player : TESTS.keySet()) { assertEquals(score + 5, player.getScore());
int expected = TESTS.get(player); assertNotEquals(score, player.getScore());
player.updateScore(3);
assertEquals(expected, player.getScore());
expected -= 5;
player.updateScore(-5);
assertEquals(expected, player.getScore());
}
} }
@Test @Test
void is_winner() { void test_isWinner() {
final HashMap<Player, Boolean> TESTS = new HashMap<>() {{ final HashMap<Player, Boolean> TESTS = new HashMap<>() {{
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 5,5,5),true); put(fixture[0], true);
put(new Player(new BigDecimal(2), new Game(), new User(), 20, false, 5,5,5),false); put(fixture[1], false);
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 5,5,5),true); put(fixture[2], true);
}}; }};
for (Player player : TESTS.keySet()) { for (Player player : TESTS.keySet()) {
assertEquals(TESTS.get(player), player.isWinner()); assertEquals(TESTS.get(player), player.isWinner());
} }
} }
@Test @Test
void set_winner() { void test_setWinner() {
Player[] players = new Player[]{ Player player = fixture[1];
new Player(new BigDecimal(1), new Game(), new User(), 10, false, 5,5,5), assertFalse(player.isWinner());
new Player(new BigDecimal(2), new Game(), new User(), 20, false, 5,5,5),
new Player(new BigDecimal(3), new Game(), new User(), 15, false, 5,5,5),
};
for (Player player: players){
player.setWinner(); player.setWinner();
assertTrue(player.isWinner()); assertTrue(player.isWinner());
} }
}
@Test @Test
void get_click_count() { void test_getClickCount() {
final HashMap<Player, Integer> TESTS = new HashMap<>() {{ final HashMap<Player, Integer> TESTS = new HashMap<>() {{
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,5,5),6); put(fixture[0], 6);
put(new Player(new BigDecimal(2), new Game(), new User(), 20, false,4 ,4,1),4); put(fixture[1], 4);
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 2,5,5),2); put(fixture[2], 10);
}}; }};
for (Player player : TESTS.keySet()) { for (Player player : TESTS.keySet()) {
assertEquals(TESTS.get(player), player.getClickCount()); assertEquals(TESTS.get(player), player.getClickCount());
} }
} }
@Test @Test
void set_click_count() { void test_setClickCount() {
final HashMap<Player, Integer> TESTS = new HashMap<>() {{ Player player = fixture[0];
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,5,5),3); int clickCount = player.getClickCount();
put(new Player(new BigDecimal(2), new Game(), new User(), 20, false,4 ,4,1),3);
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 2,5,5),3); // Set a new click count
}};
for (Player player : TESTS.keySet()) {
int expected = TESTS.get(player);
player.setClickCount(3); player.setClickCount(3);
assertEquals(expected, player.getClickCount()); assertEquals(3, player.getClickCount());
} assertNotEquals(clickCount, player.getClickCount());
} }
@Test @Test
void increment_click_count() { void test_incrementClickCount() {
final HashMap<Player, Integer> TESTS = new HashMap<>() {{ Player player = fixture[0];
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,5,5),7); int clickCount = player.getClickCount();
put(new Player(new BigDecimal(2), new Game(), new User(), 20, false,4 ,4,1),5);
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 2,5,5),3); // Increment the click count
}};
for (Player player : TESTS.keySet()) {
int expected = TESTS.get(player);
player.incrementClickCount(); player.incrementClickCount();
assertEquals(expected, player.getClickCount()); assertEquals(clickCount + 1, player.getClickCount());
} assertNotEquals(clickCount, player.getClickCount());
} }
@Test @Test
void get_right_click_count() { void test_getRightClickCount() {
final HashMap<Player, Integer> TESTS = new HashMap<>() {{ final HashMap<Player, Integer> TESTS = new HashMap<>() {{
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,5,5),5); put(fixture[0], 5);
put(new Player(new BigDecimal(2), new Game(), new User(), 20, false,4 ,4,1),4); put(fixture[1], 2);
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 2,3,5),3); put(fixture[2], 5);
}}; }};
for (Player player : TESTS.keySet()) { for (Player player : TESTS.keySet()) {
assertEquals(TESTS.get(player), player.getRightClickCount()); assertEquals(TESTS.get(player), player.getRightClickCount());
} }
} }
@Test @Test
void set_right_click_count() { void test_setRightClickCount() {
final HashMap<Player, Integer> TESTS = new HashMap<>() {{ Player player = fixture[0];
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,5,5),3); int rightClickCount = player.getRightClickCount();
put(new Player(new BigDecimal(2), new Game(), new User(), 20, false,4 ,4,1),3);
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 2,5,5),3); // Set a new right click count
}};
for (Player player : TESTS.keySet()) {
int expected = TESTS.get(player);
player.setRightClickCount(3); player.setRightClickCount(3);
assertEquals(expected, player.getRightClickCount()); assertEquals(3, player.getRightClickCount());
} assertNotEquals(rightClickCount, player.getRightClickCount());
} }
@Test @Test
void increment_right_click_count() { void test_incrementRightClickCount() {
final HashMap<Player, Integer> TESTS = new HashMap<>() {{ Player player = fixture[0];
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,5,5),6); int rightClickCount = player.getRightClickCount();
put(new Player(new BigDecimal(2), new Game(), new User(), 20, false,8 ,4,1),5);
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 9,5,5),6); // Increment the right click count
}};
for (Player player : TESTS.keySet()) {
int expected = TESTS.get(player);
player.incrementRightClickCount(); player.incrementRightClickCount();
assertEquals(expected, player.getRightClickCount()); assertEquals(rightClickCount + 1, player.getRightClickCount());
} assertNotEquals(rightClickCount, player.getRightClickCount());
} }
@Test @Test
void get_ratio_right_click() { void test_getRatioRightClick() {
final HashMap<Player, Double> TESTS = new HashMap<>() {{ final HashMap<Player, Double> TESTS = new HashMap<>() {{
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,3,5),50.); put(fixture[0], 83.33);
put(new Player(new BigDecimal(2), new Game(), new User(), 20, false,4 ,1,1),25.); put(fixture[1], 50.);
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 17,5,5),29.41); put(fixture[2], 50.);
}}; }};
for (Player player : TESTS.keySet()) { for (Player player : TESTS.keySet()) {
assertEquals(TESTS.get(player), player.getRatioRightClick()); assertEquals(TESTS.get(player), player.getRatioRightClick());
} }
@@ -271,101 +251,70 @@ class PlayerTest {
} }
@Test @Test
void get_rapid_click_count() { void test_getRapidClickCount() {
final HashMap<Player, Integer> TESTS = new HashMap<>() {{ final HashMap<Player, Integer> TESTS = new HashMap<>() {{
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,3,5),5); put(fixture[0], 5);
put(new Player(new BigDecimal(2), new Game(), new User(), 20, false,4 ,1,1),1); put(fixture[1], 1);
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 17,3,2),2); put(fixture[2], 5);
}}; }};
for (Player player : TESTS.keySet()) { for (Player player : TESTS.keySet()) {
assertEquals(TESTS.get(player), player.getRapidClickCount()); assertEquals(TESTS.get(player), player.getRapidClickCount());
} }
} }
@Test @Test
void set_rapid_click_count() { void test_setRapidClickCount() {
final HashMap<Player, Integer> TESTS = new HashMap<>() {{ Player player = fixture[0];
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,5,5),3); int rapidClickCount = player.getRapidClickCount();
put(new Player(new BigDecimal(2), new Game(), new User(), 20, false,4 ,4,1),3);
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 2,5,5),3);
}};
for (Player player : TESTS.keySet()) {
int expected = TESTS.get(player);
player.setRightClickCount(3);
assertEquals(expected, player.getRightClickCount());
}
// Set a new rapid click count
player.setRapidClickCount(3);
assertEquals(3, player.getRapidClickCount());
assertNotEquals(rapidClickCount, player.getRapidClickCount());
} }
@Test @Test
void increment_rapid_click_count() { void test_incrementRapidClickCount() {
final HashMap<Player, Integer> TESTS = new HashMap<>() {{ Player player = fixture[0];
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,3,5),6); int rapidClickCount = player.getRapidClickCount();
put(new Player(new BigDecimal(2), new Game(), new User(), 20, false,4 ,1,1),2);
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 17,3,2),3); // Increment the rapid click count
}};
for (Player player : TESTS.keySet()) {
int expected = TESTS.get(player);
player.incrementRapidClickCount(); player.incrementRapidClickCount();
assertEquals(expected, player.getRapidClickCount()); assertEquals(rapidClickCount + 1, player.getRapidClickCount());
} assertNotEquals(rapidClickCount, player.getRapidClickCount());
} }
@Test @Test
void get_ratio_rapid_click() { void test_getRatioRapidClick() {
final HashMap<Player, Double> TESTS = new HashMap<>() {{ final HashMap<Player, Double> TESTS = new HashMap<>() {{
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,3,5),83.33); put(fixture[0], 83.33);
put(new Player(new BigDecimal(2), new Game(), new User(), 20, false,4 ,1,1),25.); put(fixture[1], 25.);
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 17,3,2),11.76); put(fixture[2], 50.);
}}; }};
for (Player player : TESTS.keySet()) { for (Player player : TESTS.keySet()) {
assertEquals(TESTS.get(player), player.getRatioRapidClick()); assertEquals(TESTS.get(player), player.getRatioRapidClick());
} }
} }
@Test @Test
void get_deck() { void test_getDeck() {
Deck[] decks = new Deck[]{
new Deck(2,10),
new Deck(4,13),
new Deck(3,6),
};
Game[] games = new Game[]{
new Game(new BigDecimal(1), new Date(), Game.Difficulty.EASY,20,2,10,null),
new Game(new BigDecimal(2), new Date(), Game.Difficulty.EASY,52,4,13,null),
new Game(new BigDecimal(3), new Date(), Game.Difficulty.EASY,18,3,6,null),
};
final HashMap<Player, Deck> TESTS = new HashMap<>() {{ final HashMap<Player, Deck> TESTS = new HashMap<>() {{
put(new Player(games[0], new User()), decks[0]); put(fixture[0], new Deck(2,10));
put(new Player(games[1], new User()), decks[1]); put(fixture[1], new Deck(4,13));
put(new Player(games[2], new User()), decks[2]); put(fixture[2], new Deck(3,6));
}}; }};
for (Player player : TESTS.keySet()) { for (Player player : TESTS.keySet()) {
assertEquals(TESTS.get(player), player.getDeck()); assertEquals(TESTS.get(player), player.getDeck());
} }
} }
@Test @Test
void test_to_string() { void test_toString() {
Game game = new Game(new BigDecimal(1), new Date(2024-1900,3,27), Game.Difficulty.EASY,20,4,5,null); String expected = "Player{id=4, game=Game{id=4, createdAt=Sun Mar 04 00:00:00 CET 2001, difficulty=HARD, nbRounds=18, nbColors=3, nbValuesPerColor=6}, user=User{id='null', username=username4, email=email4, birth='Tue Feb 01 00:00:00 CET 2000', gender='OTHER'}, score=15, winner=true, clickCount=10, rightClickCount=5, rapidClickCount=5}";
User user = new User("username1", "email1", "password1", new Date(1996-1900,2,20), User.Gender.MALE);
final HashMap<Player, String> TESTS = new HashMap<>() {{ assertEquals(expected, fixture[3].toString());
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,5,5),
"Player{id=1, game=Game{id=null, createdAt=null, difficulty=null, nbRounds=0, nbColors=0, nbValuesPerColor=0}, " +
"user=User{id='null', username=null, email=null, birth='null', gender='null'}, " +
"score=10, winner=true, clickCount=6, rightClickCount=5, rapidClickCount=5}");
put(new Player(new BigDecimal(2), game, new User(), 20, false, 4,2,1),
"Player{id=2, game=Game{id=1, createdAt=Sat Apr 27 00:00:00 CEST 2024, difficulty=EASY, nbRounds=20, nbColors=4, nbValuesPerColor=5}, " +
"user=User{id='null', username=null, email=null, birth='null', gender='null'}, " +
"score=20, winner=false, clickCount=4, rightClickCount=2, rapidClickCount=1}");
put(new Player(new BigDecimal(3), new Game(), user, 15, true, 10,5,5),
"Player{id=3, game=Game{id=null, createdAt=null, difficulty=null, nbRounds=0, nbColors=0, nbValuesPerColor=0}, " +
"user=User{id='null', username=username1, email=email1, birth='Wed Mar 20 00:00:00 CET 1996', gender='MALE'}, " +
"score=15, winner=true, clickCount=10, rightClickCount=5, rapidClickCount=5}");
}};
for (Player player : TESTS.keySet()) {
assertEquals(TESTS.get(player), player.toString());
}
} }
} }