mirror of
https://github.com/kmitresse/Cards-Rush.git
synced 2026-05-14 01:21:49 +00:00
test(DevWeb): Add unit tests for Card and Deck
This commit is contained in:
Lucàs
@@ -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
|
||||
static void setup() {
|
||||
FIXTURE = new Card[]{
|
||||
// Card Value
|
||||
new Card(Card.Color.HEART, Card.Value.ONE),
|
||||
new Card(Card.Color.HEART, Card.Value.TWO),
|
||||
new Card(Card.Color.HEART, Card.Value.THREE),
|
||||
new Card(Card.Color.CLUBS, Card.Value.FOUR),
|
||||
new Card(Card.Color.CLUBS, Card.Value.FIVE),
|
||||
new Card(Card.Color.CLUBS, Card.Value.SIX),
|
||||
new Card(Card.Color.DIAMONDS, Card.Value.SEVEN),
|
||||
new Card(Card.Color.DIAMONDS, Card.Value.EIGHT),
|
||||
new Card(Card.Color.DIAMONDS, Card.Value.NINE),
|
||||
new Card(Card.Color.SPADES, Card.Value.TEN),
|
||||
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 with correct Value
|
||||
new Card(Card.Color.HEART, Card.Value.ACE);
|
||||
new Card(Card.Color.HEART, Card.Value.TWO);
|
||||
new Card(Card.Color.HEART, Card.Value.THREE);
|
||||
new Card(Card.Color.CLUBS, Card.Value.FOUR);
|
||||
new Card(Card.Color.CLUBS, Card.Value.FIVE);
|
||||
new Card(Card.Color.CLUBS, Card.Value.SIX);
|
||||
new Card(Card.Color.DIAMONDS, Card.Value.SEVEN);
|
||||
new Card(Card.Color.DIAMONDS, Card.Value.EIGHT);
|
||||
new Card(Card.Color.DIAMONDS, Card.Value.NINE);
|
||||
new Card(Card.Color.SPADES, Card.Value.TEN);
|
||||
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
|
||||
new Card(Card.Color.HEART, Card.Value.ONE),
|
||||
new Card(Card.Color.CLUBS, Card.Value.ONE),
|
||||
new Card(Card.Color.DIAMONDS, Card.Value.ONE),
|
||||
new Card(Card.Color.SPADES, Card.Value.ONE),
|
||||
};
|
||||
// Card with correct Color
|
||||
new Card(Card.Color.HEART, Card.Value.ACE);
|
||||
new Card(Card.Color.CLUBS, Card.Value.ACE);
|
||||
new Card(Card.Color.DIAMONDS, Card.Value.ACE);
|
||||
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() {
|
||||
Card.Color[] expected = new Card.Color[] {
|
||||
Card.Color.HEART,
|
||||
Card.Color.HEART,
|
||||
Card.Color.HEART,
|
||||
Card.Color.CLUBS,
|
||||
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,
|
||||
void test_getColor() {
|
||||
final HashMap<Card, Card.Color> TESTS = new HashMap<>() {{
|
||||
put(new Card(Card.Color.HEART, Card.Value.ACE), Card.Color.HEART);
|
||||
put(new Card(Card.Color.CLUBS, Card.Value.TWO), Card.Color.CLUBS);
|
||||
put(new Card(Card.Color.DIAMONDS, Card.Value.THREE), Card.Color.DIAMONDS);
|
||||
put(new Card(Card.Color.SPADES, Card.Value.FOUR), Card.Color.SPADES);
|
||||
}};
|
||||
|
||||
Card.Color.HEART,
|
||||
Card.Color.CLUBS,
|
||||
Card.Color.DIAMONDS,
|
||||
Card.Color.SPADES,
|
||||
};
|
||||
for (Card card : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(card), card.getColor());
|
||||
}
|
||||
|
||||
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() {
|
||||
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,
|
||||
void test_toString() {
|
||||
|
||||
Card.Value.ONE,
|
||||
Card.Value.ONE,
|
||||
Card.Value.ONE,
|
||||
Card.Value.ONE,
|
||||
};
|
||||
final HashMap<Card, String> TESTS = new HashMap<>() {{
|
||||
put(new Card(Card.Color.HEART, Card.Value.ACE), "Card{color=HEART, value=ACE}");
|
||||
put(new Card(Card.Color.CLUBS, Card.Value.TWO), "Card{color=CLUBS, value=TWO}");
|
||||
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++) {
|
||||
assertEquals(expected[i], FIXTURE[i].getValue());
|
||||
for (Card card : TESTS.keySet()) {
|
||||
assertEquals(TESTS.get(card), card.toString());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void to_string_return_right_format() {
|
||||
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}",
|
||||
void test_CardValue() {
|
||||
|
||||
"Card{color=HEART, value=ONE}",
|
||||
"Card{color=CLUBS, value=ONE}",
|
||||
"Card{color=DIAMONDS, value=ONE}",
|
||||
"Card{color=SPADES, value=ONE}",
|
||||
// Expect the right number of values
|
||||
assertEquals(13, Card.Value.values().length);
|
||||
|
||||
// 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++) {
|
||||
assertEquals(expected[i], FIXTURE[i].toString());
|
||||
for (int index = 0; index < EXPECTED_NAMES.length; index++) {
|
||||
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
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
|
||||
@BeforeAll
|
||||
static void setup() {
|
||||
FIXTURE = new Deck[] {
|
||||
new Deck(4, 13),
|
||||
new Deck(4, 13),
|
||||
};
|
||||
@Test
|
||||
void test_constructor() {
|
||||
new Deck(4, 13);
|
||||
new Deck(3, 10);
|
||||
new Deck(2, 7);
|
||||
new Deck(1, 1);
|
||||
}
|
||||
|
||||
@Test
|
||||
void throw_error_on_creation_of_invalid_deck_with_an_invalid_color() {
|
||||
// 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() {
|
||||
void test_constructor_deckWithSameParametersHaveSameCards() {
|
||||
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.shuffleSetOfCard(mockDeck.getCards());
|
||||
for (int i = 0; i < initialCards.size(); i++) {
|
||||
assertTrue(mockDeck.getCards().contains(initialCards.get(i)));
|
||||
}
|
||||
Deck mockDeck2 = new Deck(4,13);
|
||||
mockDeck2.shuffle();
|
||||
assertEquals(mockDeck, mockDeck2);
|
||||
}
|
||||
|
||||
@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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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),
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user