mirror of
https://github.com/kmitresse/Cards-Rush.git
synced 2026-05-13 17:11:49 +00:00
feat: dev-web - User and Player tests
This commit is contained in:
kmitresse
@@ -250,8 +250,8 @@ public class Game implements Serializable {
|
||||
this.players.add(player);
|
||||
}
|
||||
|
||||
public ArrayList<Card> getDeck() {
|
||||
return deck.getCards();
|
||||
public Deck getDeck() {
|
||||
return deck;
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -228,7 +228,7 @@ public class Player implements Serializable {
|
||||
* @return le pourcentage de clics corrects du joueur sur la partie courante
|
||||
*/
|
||||
public double getRatioRightClick() {
|
||||
return (double) rightClickCount * 100 / clickCount;
|
||||
return (double) Math.abs(rightClickCount * 10000 / clickCount) / 100;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -258,11 +258,11 @@ public class Player implements Serializable {
|
||||
* @return le pourcentage de clics rapides du joueur sur la partie courante
|
||||
*/
|
||||
public double getRatioRapidClick() {
|
||||
return (double) rapidClickCount * 100 / clickCount;
|
||||
return (double) Math.abs(rapidClickCount * 10000 / clickCount) / 100;
|
||||
}
|
||||
|
||||
public ArrayList<Card> getDeck() {
|
||||
return deck.getCards();
|
||||
public Deck getDeck() {
|
||||
return deck;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -23,6 +23,8 @@ import java.io.Serializable;
|
||||
import java.math.BigDecimal;
|
||||
import java.security.MessageDigest;
|
||||
import java.security.NoSuchAlgorithmException;
|
||||
import java.time.LocalDate;
|
||||
import java.time.Period;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Date;
|
||||
import java.util.Objects;
|
||||
@@ -81,6 +83,9 @@ public class User implements Serializable {
|
||||
* @param gender le genre
|
||||
*/
|
||||
public User(String username, String email, String password, Date birth, Gender gender) {
|
||||
if (!isValidBirthDate(birth)){
|
||||
throw new IllegalArgumentException("La date de naissance n'est pas valide");
|
||||
}
|
||||
this.username = username;
|
||||
this.email = email;
|
||||
this.password = hashPassword(password);
|
||||
@@ -99,6 +104,9 @@ public class User implements Serializable {
|
||||
* @param gender le genre
|
||||
*/
|
||||
public User(BigDecimal id, String username, String email, String password, Date birth, Gender gender, ArrayList<Player> playedGames) {
|
||||
if (!isValidBirthDate(birth)){
|
||||
throw new IllegalArgumentException("La date de naissance n'est pas valide");
|
||||
}
|
||||
this.id = id;
|
||||
this.username = username;
|
||||
this.email = email;
|
||||
@@ -114,7 +122,7 @@ public class User implements Serializable {
|
||||
* @param password le mot de passe à hasher
|
||||
* @return le mot de passe hashé
|
||||
*/
|
||||
private static String hashPassword(String password) {
|
||||
public static String hashPassword(String password) {
|
||||
try {
|
||||
MessageDigest digest = MessageDigest.getInstance("SHA-256");
|
||||
|
||||
@@ -223,18 +231,6 @@ public class User implements Serializable {
|
||||
this.gender = gender;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calcule l'âge de l'utilisateur
|
||||
*
|
||||
* @return l'âge de l'utilisateur en années
|
||||
*/
|
||||
public int getAge() {
|
||||
Date currentDate = new Date();
|
||||
long diff = currentDate.getTime() - birth.getTime();
|
||||
long diffDays = diff / (24 * 60 * 60 * 1000);
|
||||
return (int) (diffDays / 365);
|
||||
}
|
||||
|
||||
/**
|
||||
* Prédicat qui vérifie si le mot de passe fourni est correct
|
||||
*
|
||||
@@ -283,7 +279,7 @@ public class User implements Serializable {
|
||||
* @return le pourcentage de victoire
|
||||
*/
|
||||
public double getWinRate(){
|
||||
return (double) getNbWin() * 100 / getNbPlayedGame();
|
||||
return (double) Math.abs(getNbWin() * 10000 / getNbPlayedGame()) /100;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -318,7 +314,7 @@ public class User implements Serializable {
|
||||
* @return le pourcentage de clics réussi
|
||||
*/
|
||||
public double getRightClickPercentRate(){
|
||||
return (double) getNbRightClicks() * 100 / getNbClicks();
|
||||
return (double) Math.abs(getNbRightClicks() * 10000 / getNbClicks())/100;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -340,15 +336,21 @@ public class User implements Serializable {
|
||||
* @return le pourcentage de clics les plus rapides
|
||||
*/
|
||||
public double getRapidClickPercentRate(){
|
||||
return (double) getNbRapidClicks() * 100 / getNbClicks();
|
||||
return (double) Math.abs(getNbRapidClicks() * 10000 / getNbClicks())/100;
|
||||
}
|
||||
|
||||
public boolean isValidBirthDate(Date birthdate){
|
||||
Date currentDate = new Date();
|
||||
return birthdate.before(currentDate) || birthdate.equals(currentDate);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return String.format(
|
||||
"User{id = '%s', username='%s', email='%s', birth=%s, gender=%s}",
|
||||
"User{id='%s', username=%s, email=%s, birth='%s', gender='%s'}",
|
||||
id != null ? id.toString() : "null",
|
||||
username,
|
||||
email,
|
||||
birth.toString(),
|
||||
gender.toString()
|
||||
);
|
||||
|
||||
@@ -51,7 +51,6 @@ class CardTest {
|
||||
for (Card card : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(card), card.getColor());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
@@ -1,6 +1,9 @@
|
||||
package uppa.project.pojo;
|
||||
|
||||
import java.math.BigDecimal;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Date;
|
||||
import java.util.HashMap;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
@@ -8,191 +11,341 @@ import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class PlayerTest {
|
||||
|
||||
static Player[] FIXTURE;
|
||||
|
||||
@BeforeAll
|
||||
static void setUp() {
|
||||
FIXTURE = new Player[] {
|
||||
new Player(new BigDecimal(0), new Game(), new User(), 15, false, 20, 15, 6 ),
|
||||
new Player(new BigDecimal(0), new Game(), new User(), 13, false, 15, 13, 8),
|
||||
new Player(new BigDecimal(0), new Game(), new User(), 8, false, 10, 8, 2)
|
||||
};
|
||||
}
|
||||
|
||||
@Test
|
||||
void test_hash_code() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
void test_constructor() {
|
||||
new Player();
|
||||
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
|
||||
void get_game() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
Game[] games = new Game[]{
|
||||
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),
|
||||
};
|
||||
|
||||
final HashMap<Player, Game> TESTS = new HashMap<>() {{
|
||||
put(new Player(games[0], new User()), games[0]);
|
||||
put(new Player(games[1], new User()), games[1]);
|
||||
put(new Player(games[2], new User()), games[2]);
|
||||
}};
|
||||
for (Player player : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(player), player.getGame());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void set_game() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
Game[] games = new Game[]{
|
||||
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),
|
||||
};
|
||||
Game game =
|
||||
new Game(new BigDecimal(4), new Date(), Game.Difficulty.HARD,20,4,5,null);
|
||||
|
||||
final HashMap<Player, Game> TESTS = new HashMap<>() {{
|
||||
put(new Player(games[0], new User()), game);
|
||||
put(new Player(games[1], new User()), game);
|
||||
put(new Player(games[2], new User()), game);
|
||||
}};
|
||||
for (Player player : TESTS.keySet()) {
|
||||
Game expected = TESTS.get(player);
|
||||
player.setGame(game);
|
||||
assertEquals(expected, player.getGame());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void get_user() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
Game[] games = new Game[]{
|
||||
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<>() {{
|
||||
put(new Player(games[0], users[0]), users[0]);
|
||||
put(new Player(games[1], users[1]), users[1]);
|
||||
put(new Player(games[2], users[2]), users[2]);
|
||||
}};
|
||||
for (Player player : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(player), player.getUser());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
void set_user() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
Game[] games = new Game[]{
|
||||
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),
|
||||
};
|
||||
User user = new User("username000", "email000", "password000", new Date(), User.Gender.OTHER);
|
||||
|
||||
final HashMap<Player, User> TESTS = new HashMap<>() {{
|
||||
put(new Player(games[0], users[0]), user);
|
||||
put(new Player(games[1], users[1]), user);
|
||||
put(new Player(games[2], users[2]), user);
|
||||
}};
|
||||
for (Player player : TESTS.keySet()) {
|
||||
User expected =TESTS.get(player);
|
||||
player.setUser(user);
|
||||
assertEquals(expected, player.getUser());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void get_score() {
|
||||
int[] expected = new int[]{15, 13, 8};
|
||||
for (int i = 0; i < FIXTURE.length; i++) {
|
||||
assertEquals(expected[i], FIXTURE[i].getScore());
|
||||
final HashMap<Player, Integer> TESTS = new HashMap<>() {{
|
||||
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 5,5,5),10);
|
||||
put(new Player(new BigDecimal(2), new Game(), new User(), 20, true, 5,5,5),20);
|
||||
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 5,5,5),15);;
|
||||
}};
|
||||
for (Player player : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(player), player.getScore());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void set_score() {
|
||||
int[] expected = new int[]{20, 9, 1};
|
||||
for (int i = 0; i < FIXTURE.length; i++) {
|
||||
FIXTURE[i].setScore(expected[i]);
|
||||
assertEquals(expected[i], FIXTURE[i].getScore());
|
||||
final HashMap<Player, Integer> TESTS = new HashMap<>() {{
|
||||
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 5,5,5),50);
|
||||
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);
|
||||
}};
|
||||
for (Player player : TESTS.keySet()) {
|
||||
int expected = TESTS.get(player);
|
||||
player.setScore(50);
|
||||
assertEquals(expected, player.getScore());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void update_score() {
|
||||
int[] expected1 = new int[]{16, 14, 9};
|
||||
int[] expected2 = new int[]{11, 9, 4};
|
||||
for (int i = 0; i < FIXTURE.length; i++) {
|
||||
FIXTURE[i].updateScore(1);
|
||||
assertEquals(expected1[i], FIXTURE[i].getScore());
|
||||
FIXTURE[i].updateScore(-5);
|
||||
assertEquals(expected2[i], FIXTURE[i].getScore());
|
||||
final HashMap<Player, Integer> TESTS = new HashMap<>() {{
|
||||
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 5,5,5),13);
|
||||
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);
|
||||
}};
|
||||
for (Player player : TESTS.keySet()) {
|
||||
int expected = TESTS.get(player);
|
||||
player.updateScore(3);
|
||||
assertEquals(expected, player.getScore());
|
||||
expected -= 5;
|
||||
player.updateScore(-5);
|
||||
assertEquals(expected, player.getScore());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void is_winner() {
|
||||
boolean[] expected = new boolean[]{false, false, false};
|
||||
for (int i = 0; i < FIXTURE.length; i++) {
|
||||
assertEquals(expected[i], FIXTURE[i].isWinner());
|
||||
final HashMap<Player, Boolean> TESTS = new HashMap<>() {{
|
||||
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 5,5,5),true);
|
||||
put(new Player(new BigDecimal(2), new Game(), new User(), 20, false, 5,5,5),false);
|
||||
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 5,5,5),true);
|
||||
}};
|
||||
for (Player player : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(player), player.isWinner());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void set_winner() {
|
||||
boolean[] expected = new boolean[]{true, true, true};
|
||||
for (int i = 0; i < FIXTURE.length; i++) {
|
||||
FIXTURE[i].setWinner();
|
||||
assertEquals(expected[i], FIXTURE[i].isWinner());
|
||||
Player[] players = new Player[]{
|
||||
new Player(new BigDecimal(1), new Game(), new User(), 10, false, 5,5,5),
|
||||
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();
|
||||
assertTrue(player.isWinner());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void get_click_count() {
|
||||
int[] expected = new int[]{20, 15, 10};
|
||||
for (int i = 0; i < FIXTURE.length; i++) {
|
||||
assertEquals(expected[i], FIXTURE[i].getClickCount());
|
||||
final HashMap<Player, Integer> TESTS = new HashMap<>() {{
|
||||
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,5,5),6);
|
||||
put(new Player(new BigDecimal(2), new Game(), new User(), 20, false,4 ,4,1),4);
|
||||
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 2,5,5),2);
|
||||
}};
|
||||
for (Player player : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(player), player.getClickCount());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void set_click_count() {
|
||||
int[] expected = new int[]{25, 20, 15};
|
||||
for (int i = 0; i < FIXTURE.length; i++) {
|
||||
FIXTURE[i].setClickCount(expected[i]);
|
||||
assertEquals(expected[i], FIXTURE[i].getClickCount());
|
||||
final HashMap<Player, Integer> TESTS = new HashMap<>() {{
|
||||
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,5,5),3);
|
||||
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.setClickCount(3);
|
||||
assertEquals(expected, player.getClickCount());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void increment_click_count() {
|
||||
int[] expected = new int[]{21, 16, 11};
|
||||
for (int i = 0; i < FIXTURE.length; i++) {
|
||||
FIXTURE[i].incrementClickCount();
|
||||
assertEquals(expected[i], FIXTURE[i].getClickCount());
|
||||
final HashMap<Player, Integer> TESTS = new HashMap<>() {{
|
||||
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,5,5),7);
|
||||
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);
|
||||
}};
|
||||
for (Player player : TESTS.keySet()) {
|
||||
int expected = TESTS.get(player);
|
||||
player.incrementClickCount();
|
||||
assertEquals(expected, player.getClickCount());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void get_right_click_count() {
|
||||
int[] expected = new int[]{15, 13, 8};
|
||||
for (int i = 0; i < FIXTURE.length; i++) {
|
||||
assertEquals(expected[i], FIXTURE[i].getRightClickCount());
|
||||
final HashMap<Player, Integer> TESTS = new HashMap<>() {{
|
||||
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,5,5),5);
|
||||
put(new Player(new BigDecimal(2), new Game(), new User(), 20, false,4 ,4,1),4);
|
||||
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 2,3,5),3);
|
||||
}};
|
||||
for (Player player : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(player), player.getRightClickCount());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void set_right_click_count() {
|
||||
int[] expected = new int[]{20, 15, 10};
|
||||
for (int i = 0; i < FIXTURE.length; i++) {
|
||||
FIXTURE[i].setRightClickCount(expected[i]);
|
||||
assertEquals(expected[i], FIXTURE[i].getRightClickCount());
|
||||
final HashMap<Player, Integer> TESTS = new HashMap<>() {{
|
||||
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,5,5),3);
|
||||
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());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void increment_right_click_count() {
|
||||
int[] expected = new int[]{16, 14, 9};
|
||||
for (int i = 0; i < FIXTURE.length; i++) {
|
||||
FIXTURE[i].incrementRightClickCount();
|
||||
assertEquals(expected[i], FIXTURE[i].getRightClickCount());
|
||||
final HashMap<Player, Integer> TESTS = new HashMap<>() {{
|
||||
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,5,5),6);
|
||||
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);
|
||||
}};
|
||||
for (Player player : TESTS.keySet()) {
|
||||
int expected = TESTS.get(player);
|
||||
player.incrementRightClickCount();
|
||||
assertEquals(expected, player.getRightClickCount());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void get_ratio_right_click() {
|
||||
double[] expected = new double[]{0.75*100, 0.8666666666666667*100, 0.8*100};
|
||||
for (int i = 0; i < FIXTURE.length; i++) {
|
||||
assertEquals(expected[i], FIXTURE[i].getRatioRightClick());
|
||||
final HashMap<Player, Double> TESTS = new HashMap<>() {{
|
||||
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,3,5),50.);
|
||||
put(new Player(new BigDecimal(2), new Game(), new User(), 20, false,4 ,1,1),25.);
|
||||
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 17,5,5),29.41);
|
||||
}};
|
||||
for (Player player : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(player), player.getRatioRightClick());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
void get_rapid_click_count() {
|
||||
int[] expected = new int[]{6, 8, 2};
|
||||
for (int i = 0; i < FIXTURE.length; i++) {
|
||||
assertEquals(expected[i], FIXTURE[i].getRapidClickCount());
|
||||
final HashMap<Player, Integer> TESTS = new HashMap<>() {{
|
||||
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,3,5),5);
|
||||
put(new Player(new BigDecimal(2), new Game(), new User(), 20, false,4 ,1,1),1);
|
||||
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 17,3,2),2);
|
||||
}};
|
||||
for (Player player : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(player), player.getRapidClickCount());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void set_rapid_click_count() {
|
||||
int[] expected = new int[]{10, 15, 20};
|
||||
for (int i = 0; i < FIXTURE.length; i++) {
|
||||
FIXTURE[i].setRapidClickCount(expected[i]);
|
||||
assertEquals(expected[i], FIXTURE[i].getRapidClickCount());
|
||||
final HashMap<Player, Integer> TESTS = new HashMap<>() {{
|
||||
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,5,5),3);
|
||||
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.getRapidClickCount());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
void increment_rapid_click_count() {
|
||||
int[] expected = new int[]{7, 9, 3};
|
||||
for (int i = 0; i < FIXTURE.length; i++) {
|
||||
FIXTURE[i].incrementRapidClickCount();
|
||||
assertEquals(expected[i], FIXTURE[i].getRapidClickCount());
|
||||
final HashMap<Player, Integer> TESTS = new HashMap<>() {{
|
||||
put(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 6,3,5),6);
|
||||
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);
|
||||
}};
|
||||
for (Player player : TESTS.keySet()) {
|
||||
int expected = TESTS.get(player);
|
||||
player.incrementRightClickCount();
|
||||
assertEquals(expected, player.getRapidClickCount());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void get_ratio_rapid_click() {
|
||||
double[] expected = new double[]{0.3*100, 0.5333333333333333*100, 0.2*100};
|
||||
for (int i = 0; i < FIXTURE.length; i++) {
|
||||
assertEquals(expected[i], FIXTURE[i].getRatioRapidClick());
|
||||
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(new Player(new BigDecimal(2), new Game(), new User(), 20, false,4 ,1,1),25.);
|
||||
put(new Player(new BigDecimal(3), new Game(), new User(), 15, true, 17,3,2),11.76);
|
||||
}};
|
||||
for (Player player : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(player), player.getRatioRapidClick());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void get_deck() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
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<>() {{
|
||||
put(new Player(games[0], new User()), decks[0]);
|
||||
put(new Player(games[1], new User()), decks[1]);
|
||||
put(new Player(games[2], new User()), decks[2]);
|
||||
}};
|
||||
for (Player player : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(player), player.getDeck());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
@@ -1,150 +1,487 @@
|
||||
package uppa.project.pojo;
|
||||
|
||||
import java.math.BigDecimal;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Calendar;
|
||||
import java.util.Date;
|
||||
import java.util.HashMap;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class UserTest {
|
||||
|
||||
|
||||
@Test
|
||||
void getId() {
|
||||
void test_constructor() {
|
||||
new User();
|
||||
new User("username", "email", "password", new Date(), User.Gender.OTHER);
|
||||
new User(new BigDecimal(1), "username1", "email1", "password1", new Date(), User.Gender.MALE, null);
|
||||
new User(new BigDecimal(2), "username1", "email1", "password1", new Date(), User.Gender.MALE, new ArrayList<Player>());
|
||||
}
|
||||
|
||||
@Test
|
||||
void test_getId() {
|
||||
Calendar date = Calendar.getInstance();
|
||||
date.set(1996,6,3);
|
||||
date.getTime();
|
||||
final HashMap<User, BigDecimal> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(1996-1900,2,6), User.Gender.MALE,null), new BigDecimal(1));
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(1996-1900, 2, 6), User.Gender.MALE,null), new BigDecimal(2));
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(1996-1900, 3, 5), User.Gender.MALE,null), new BigDecimal(3));
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(user), user.getId());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void getUsername() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
void test_getUsername() {
|
||||
final HashMap<User, String> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(1996-1900, 1, 4), User.Gender.MALE,null), "username1");
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(1996-1900, 2, 6), User.Gender.MALE,null), "username2");
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(1996-1900, 3, 5), User.Gender.MALE,null), "username3");
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(user), user.getUsername());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void setUsername() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
void test_setUsername() {
|
||||
final HashMap<User, String> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(), User.Gender.MALE,null), "username");
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(), User.Gender.MALE,null), "username");
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(), User.Gender.MALE,null), "username");
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
String expected = TESTS.get(user);
|
||||
user.setUsername("username");
|
||||
assertEquals(expected, user.getUsername());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void getEmail() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
void test_getEmail() {
|
||||
final HashMap<User, String> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(), User.Gender.MALE,null), "email1");
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(), User.Gender.MALE,null), "email2");
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(), User.Gender.MALE,null), "email3");
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(user), user.getEmail());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void setEmail() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
void test_setEmail() {
|
||||
final HashMap<User, String> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(), User.Gender.MALE,null), "email");
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(), User.Gender.MALE,null), "email");
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(), User.Gender.MALE,null), "email");
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
String expected = TESTS.get(user);
|
||||
user.setEmail("email");
|
||||
assertEquals(expected, user.getEmail());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void getPassword() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
void test_getPassword() {
|
||||
final HashMap<User, String> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(), User.Gender.MALE,null), "password1");
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(), User.Gender.MALE,null), "password2");
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(), User.Gender.MALE,null), "password3");
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(user), user.getPassword());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
void test_setPassword() {
|
||||
String newPassword = User.hashPassword("password");
|
||||
System.out.println(newPassword);
|
||||
final HashMap<User, String> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(), User.Gender.MALE,null), newPassword);
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(), User.Gender.MALE,null), newPassword);
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(), User.Gender.MALE,null), newPassword);
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
String expected = TESTS.get(user);
|
||||
user.setPassword("password");
|
||||
assertEquals(expected, user.getPassword());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void setPassword() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
}
|
||||
|
||||
@Test
|
||||
void getBirth() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
void test_getBirth() {
|
||||
final HashMap<User, Date> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(2000-1900, 5,1), User.Gender.MALE,null), new Date(2000-1900, 5,1));
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(2023-1900, 12,25), User.Gender.MALE,null),new Date(2023-1900, 12,25));
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(2000-1900, 3,03), User.Gender.MALE,null), new Date(2000-1900, 3,03));
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(user), user.getBirth());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void setBirth() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
//TODO: DELETE
|
||||
final HashMap<User, Date> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(2000-1900, 5,1), User.Gender.MALE,null), new Date(2000-1900, 1,1));
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(2023-1900, 12,25), User.Gender.MALE,null),new Date(2000-1900, 1,1));
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(2000-1900, 3,03), User.Gender.MALE,null), new Date(2000-1900, 1,1));
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
Date expected = TESTS.get(user);
|
||||
user.setBirth(new Date(2000-1900, 1,1));
|
||||
assertEquals(expected, user.getBirth());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void getGender() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
final HashMap<User, User.Gender> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(), User.Gender.MALE,null), User.Gender.MALE);
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(), User.Gender.FEMALE,null), User.Gender.FEMALE);
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(), User.Gender.OTHER,null), User.Gender.OTHER);
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(user), user.getGender());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void setGender() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
}
|
||||
|
||||
@Test
|
||||
void getAge() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
void test_setGender() {
|
||||
final HashMap<User, User.Gender> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(), User.Gender.MALE,null), User.Gender.OTHER);
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(), User.Gender.FEMALE,null), User.Gender.OTHER);
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(), User.Gender.OTHER,null), User.Gender.OTHER);
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
User.Gender expected = TESTS.get(user);
|
||||
user.setGender(User.Gender.OTHER);
|
||||
assertEquals(expected, user.getGender());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void verifyPassword() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
String [] passwords = {"password1", "password2", "password3"};
|
||||
User[] users = {
|
||||
new User("username1", "email1", "password1", new Date(), User.Gender.MALE),
|
||||
new User("username2", "email2", "password2", new Date(), User.Gender.MALE),
|
||||
new User("username3", "email3", "password3", new Date(), User.Gender.MALE)
|
||||
};
|
||||
for (int index = 0 ; index< users.length; index++) {
|
||||
assertTrue(users[index].verifyPassword(passwords[index]));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void getPlayedGames() {
|
||||
// TODO Implement this method`
|
||||
fail();
|
||||
void test_getPlayedGames() {
|
||||
ArrayList<Player> players1 = new ArrayList<>();
|
||||
ArrayList<Player> players2 = new ArrayList<>();
|
||||
ArrayList<Player> players3 = new ArrayList<>();
|
||||
players1.add(new Player(new BigDecimal(1), new Game(), new User(), 10, true, 5,5,5));
|
||||
players2.add(new Player(new BigDecimal(2), new Game(), new User(), 10, true, 5,5,5));
|
||||
players2.add(new Player(new BigDecimal(3), new Game(), new User(), 10, true, 5,5,5));
|
||||
players3.add(new Player(new BigDecimal(4), new Game(), new User(), 10, true, 5,5,5));
|
||||
players3.add(new Player(new BigDecimal(5), new Game(), new User(), 10, true, 5,5,5));
|
||||
players3.add(new Player(new BigDecimal(6), new Game(), new User(), 10, true, 5,5,5));
|
||||
|
||||
final HashMap<User, ArrayList<Player>> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(), User.Gender.MALE, players1), players1);
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(), User.Gender.FEMALE,players2), players2);
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(), User.Gender.OTHER,players3), players3);
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(user), user.getPlayedGames());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
void getNbPlayedGame() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
void test_getNbPlayedGame() {
|
||||
ArrayList<Player> players1 = new ArrayList<>();
|
||||
ArrayList<Player> players2 = new ArrayList<>();
|
||||
ArrayList<Player> players3 = new ArrayList<>();
|
||||
players1.add(new Player());
|
||||
players2.add(new Player());
|
||||
players2.add(new Player());
|
||||
players3.add(new Player());
|
||||
players3.add(new Player());
|
||||
players3.add(new Player());
|
||||
final HashMap<User, Integer> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(), User.Gender.MALE, players1), 1);
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(), User.Gender.FEMALE,players2), 2);
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(), User.Gender.OTHER,players3), 3);
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(user), user.getPlayedGames().size());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void getNbWin() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
void test_getNbWin() {
|
||||
ArrayList<Player> players1 = new ArrayList<>();
|
||||
ArrayList<Player> players2 = new ArrayList<>();
|
||||
ArrayList<Player> players3 = new ArrayList<>();
|
||||
players1.add(new Player(new BigDecimal(1), new Game(), new User(), 10, false, 5,5,5));
|
||||
players2.add(new Player(new BigDecimal(2), new Game(), new User(), 10, true, 5,5,5));
|
||||
players2.add(new Player(new BigDecimal(3), new Game(), new User(), 10, false, 5,5,5));
|
||||
players3.add(new Player(new BigDecimal(4), new Game(), new User(), 10, true, 5,5,5));
|
||||
players3.add(new Player(new BigDecimal(5), new Game(), new User(), 10, true, 5,5,5));
|
||||
players3.add(new Player(new BigDecimal(6), new Game(), new User(), 10, true, 5,5,5));
|
||||
|
||||
final HashMap<User, Integer> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(), User.Gender.MALE, players1), 0);
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(), User.Gender.FEMALE,players2), 1);
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(), User.Gender.OTHER,players3), 3);
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(user), user.getNbWin());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void getWinRate() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
void test_getWinRate() {
|
||||
ArrayList<Player> players1 = new ArrayList<>();
|
||||
ArrayList<Player> players2 = new ArrayList<>();
|
||||
ArrayList<Player> players3 = new ArrayList<>();
|
||||
ArrayList<Player> players4 = new ArrayList<>();
|
||||
players1.add(new Player(new BigDecimal(1), new Game(), new User(), 10, false, 5,5,5));
|
||||
players2.add(new Player(new BigDecimal(2), new Game(), new User(), 10, true, 5,5,5));
|
||||
players2.add(new Player(new BigDecimal(3), new Game(), new User(), 10, false, 5,5,5));
|
||||
players3.add(new Player(new BigDecimal(4), new Game(), new User(), 10, true, 5,5,5));
|
||||
players3.add(new Player(new BigDecimal(5), new Game(), new User(), 10, true, 5,5,5));
|
||||
players3.add(new Player(new BigDecimal(6), new Game(), new User(), 10, true, 5,5,5));
|
||||
players4.add(new Player(new BigDecimal(4), new Game(), new User(), 10, true, 5,5,5));
|
||||
players4.add(new Player(new BigDecimal(5), new Game(), new User(), 10, false, 5,5,5));
|
||||
players4.add(new Player(new BigDecimal(6), new Game(), new User(), 10, true, 5,5,5));
|
||||
|
||||
final HashMap<User, Double> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(), User.Gender.MALE, players1), 0.);
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(), User.Gender.FEMALE, players2), 50.);
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(), User.Gender.OTHER, players3), 100.);
|
||||
put(new User(new BigDecimal(4), "username4", "email4", "password4",
|
||||
new Date(), User.Gender.OTHER, players4), 66.66);
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(user), user.getWinRate());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void getNbClicks() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
void test_getNbClicks() {
|
||||
ArrayList<Player> players1 = new ArrayList<>();
|
||||
ArrayList<Player> players2 = new ArrayList<>();
|
||||
ArrayList<Player> players3 = new ArrayList<>();
|
||||
players1.add(new Player(new BigDecimal(1), new Game(), new User(), 10, false, 5,5,5));
|
||||
players2.add(new Player(new BigDecimal(2), new Game(), new User(), 10, true, 6,5,5));
|
||||
players2.add(new Player(new BigDecimal(3), new Game(), new User(), 10, false, 7,5,5));
|
||||
players3.add(new Player(new BigDecimal(4), new Game(), new User(), 10, true, 8,5,5));
|
||||
players3.add(new Player(new BigDecimal(5), new Game(), new User(), 10, true, 9,5,5));
|
||||
players3.add(new Player(new BigDecimal(6), new Game(), new User(), 10, true, 10,5,5));
|
||||
|
||||
final HashMap<User, Integer> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(), User.Gender.MALE, players1), 5);
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(), User.Gender.FEMALE,players2), 6+7);
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(), User.Gender.OTHER,players3), 8+9+10);
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(user), user.getNbClicks());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void getNbRightClicks() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
void test_getNbRightClicks() {
|
||||
ArrayList<Player> players1 = new ArrayList<>();
|
||||
ArrayList<Player> players2 = new ArrayList<>();
|
||||
ArrayList<Player> players3 = new ArrayList<>();
|
||||
players1.add(new Player(new BigDecimal(1), new Game(), new User(), 10, false, 5,1,5));
|
||||
players2.add(new Player(new BigDecimal(2), new Game(), new User(), 10, true, 6,2,5));
|
||||
players2.add(new Player(new BigDecimal(3), new Game(), new User(), 10, false, 7,3,5));
|
||||
players3.add(new Player(new BigDecimal(4), new Game(), new User(), 10, true, 8,4,5));
|
||||
players3.add(new Player(new BigDecimal(5), new Game(), new User(), 10, true, 9,5,5));
|
||||
players3.add(new Player(new BigDecimal(6), new Game(), new User(), 10, true, 10,6,5));
|
||||
|
||||
final HashMap<User, Integer> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(), User.Gender.MALE, players1), 1);
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(), User.Gender.FEMALE,players2), 5);
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(), User.Gender.OTHER,players3), 15);
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(user), user.getNbRightClicks());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void getRightClickPercentRate() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
void test_getRightClickPercentRate() {
|
||||
ArrayList<Player> players1 = new ArrayList<>();
|
||||
ArrayList<Player> players2 = new ArrayList<>();
|
||||
ArrayList<Player> players3 = new ArrayList<>();
|
||||
players1.add(new Player(new BigDecimal(1), new Game(), new User(), 10, false, 5,1,5));
|
||||
players2.add(new Player(new BigDecimal(2), new Game(), new User(), 10, true, 6,2,5));
|
||||
players2.add(new Player(new BigDecimal(3), new Game(), new User(), 10, false, 7,3,5));
|
||||
players3.add(new Player(new BigDecimal(4), new Game(), new User(), 10, true, 8,4,5));
|
||||
players3.add(new Player(new BigDecimal(5), new Game(), new User(), 10, true, 9,5,5));
|
||||
players3.add(new Player(new BigDecimal(6), new Game(), new User(), 10, true, 10,6,5));
|
||||
|
||||
final HashMap<User, Double> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(), User.Gender.MALE, players1), 20.);
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(), User.Gender.FEMALE,players2), 38.46);
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(), User.Gender.OTHER,players3), 55.55);
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(user), user.getRightClickPercentRate());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void getNbRapidClicks() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
void test_getNbRapidClicks() {
|
||||
ArrayList<Player> players1 = new ArrayList<>();
|
||||
ArrayList<Player> players2 = new ArrayList<>();
|
||||
ArrayList<Player> players3 = new ArrayList<>();
|
||||
players1.add(new Player(new BigDecimal(1), new Game(), new User(), 10, false, 5,1,5));
|
||||
players2.add(new Player(new BigDecimal(2), new Game(), new User(), 10, true, 6,2,4));
|
||||
players2.add(new Player(new BigDecimal(3), new Game(), new User(), 10, false, 7,3,3));
|
||||
players3.add(new Player(new BigDecimal(4), new Game(), new User(), 10, true, 8,4,2));
|
||||
players3.add(new Player(new BigDecimal(5), new Game(), new User(), 10, true, 9,5,1));
|
||||
players3.add(new Player(new BigDecimal(6), new Game(), new User(), 10, true, 10,6,0));
|
||||
|
||||
final HashMap<User, Integer> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(), User.Gender.MALE, players1), 5);
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(), User.Gender.FEMALE,players2), 7);
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(), User.Gender.OTHER,players3), 3);
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(user), user.getNbRapidClicks());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void getRapidClickPercentRate() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
void test_getRapidClickPercentRate() {
|
||||
ArrayList<Player> players1 = new ArrayList<>();
|
||||
ArrayList<Player> players2 = new ArrayList<>();
|
||||
ArrayList<Player> players3 = new ArrayList<>();
|
||||
players1.add(new Player(new BigDecimal(1), new Game(), new User(), 10, false, 5,1,5));
|
||||
players2.add(new Player(new BigDecimal(2), new Game(), new User(), 10, true, 6,2,4));
|
||||
players2.add(new Player(new BigDecimal(3), new Game(), new User(), 10, false, 7,3,3));
|
||||
players3.add(new Player(new BigDecimal(4), new Game(), new User(), 10, true, 8,4,2));
|
||||
players3.add(new Player(new BigDecimal(5), new Game(), new User(), 10, true, 9,5,1));
|
||||
players3.add(new Player(new BigDecimal(6), new Game(), new User(), 10, true, 10,6,0));
|
||||
|
||||
final HashMap<User, Double> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(), User.Gender.MALE, players1), 100.);
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(), User.Gender.FEMALE,players2), 53.84);
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(), User.Gender.OTHER,players3), 11.11);
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(user), user.getRapidClickPercentRate());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void testToString() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
final HashMap<User, String> TESTS = new HashMap<>() {{
|
||||
put(new User(new BigDecimal(1), "username1", "email1", "password1",
|
||||
new Date(1996-1900, 1, 4), User.Gender.MALE,null),
|
||||
"User{id='1', username=username1, email=email1, birth='Sun Feb 04 00:00:00 CET 1996', gender='MALE'}"
|
||||
);
|
||||
put(new User(new BigDecimal(2), "username2", "email2", "password2",
|
||||
new Date(1996-1900, 2, 6), User.Gender.FEMALE,null),
|
||||
"User{id='2', username=username2, email=email2, birth='Wed Mar 06 00:00:00 CET 1996', gender='FEMALE'}");
|
||||
put(new User(new BigDecimal(3), "username3", "email3", "password3",
|
||||
new Date(1996-1900, 3, 5), User.Gender.OTHER,null),
|
||||
"User{id='3', username=username3, email=email3, birth='Fri Apr 05 00:00:00 CEST 1996', gender='OTHER'}");
|
||||
}};
|
||||
for (User user : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(user), user.toString());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetGender() {
|
||||
// TODO Implement this method
|
||||
fail();
|
||||
|
||||
// Expect the right number of genders
|
||||
assertEquals(3, User.Gender.values().length);
|
||||
|
||||
// Expect the right name and ordinal for each gender
|
||||
final String[] EXPECTED_NAMES = new String[]{
|
||||
"MALE", "FEMALE", "OTHER"
|
||||
};
|
||||
|
||||
for (int index = 0; index < EXPECTED_NAMES.length; index++) {
|
||||
String expectedName = EXPECTED_NAMES[index];
|
||||
User.Gender currentValue = User.Gender.values()[index];
|
||||
|
||||
assertEquals(index, currentValue.ordinal()); // Ordinal
|
||||
assertEquals(expectedName, currentValue.name()); // Name
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user