added tests and did some minor rework

src/main/java/edu/ntnu/idatt1002/callumg/cards/DeckOfCards.java

@@ -23,6 +23,15 @@ public class DeckOfCards {
         }
     }
 
+    /**
+     * Gets deck of cards.
+     *
+     * @return the deck
+     */
+    public List<PlayingCard> getCards() {
+        return cards;
+    }
+
     /**
      * Deal hand array list.
      *
@@ -31,9 +40,8 @@ public class DeckOfCards {
      * @throws IllegalArgumentException the illegal argument exception
      */
     public ArrayList<PlayingCard> dealHand(int n) throws IllegalArgumentException {
-        if (n==0) throw new IllegalArgumentException("you cant deal an empty hand");
-        if (n<0) throw new IllegalArgumentException("you cant have a negative amount of cards");
-        if (n> cards.size()) throw new IllegalArgumentException("not enough cards in deck");
+        if (n <= 0) throw new IllegalArgumentException("You cannot deal 0 or less cards.");
+        if (n > cards.size()) throw new IllegalArgumentException("You cannot deal more cards than are in the deck.");
         int totalCards;
         ArrayList<PlayingCard> cardsCopy = new ArrayList<>();
         ArrayList<PlayingCard> handOfCards = new ArrayList<>();

src/main/java/edu/ntnu/idatt1002/callumg/cards/HandOfCards.java

@@ -20,15 +20,6 @@ public class HandOfCards {
         this.handOfCards = handOfCards;
     }
 
-    /**
-     * Gets the hand of cards.
-     *
-     * @return the current hand of cards.
-     */
-    public ArrayList<PlayingCard> getHandOfCards() {
-        return handOfCards;
-    }
-
     /**
      * Gets all heart cards in a hand.
      *
@@ -47,7 +38,7 @@ public class HandOfCards {
      *
      * @return the sum of the cards
      */
-    public int sumOfCards() {
+    public int getSumOfCards() {
         return handOfCards.stream().mapToInt((card) -> card.getFace()).sum();
     }
 
@@ -57,7 +48,7 @@ public class HandOfCards {
      * @return true or false based on the statement
      */
     public boolean containsQueenOfSpades() {
-        return handOfCards.stream().anyMatch((card) -> card.getAsString().equals("S13"));
+        return handOfCards.stream().anyMatch((card) -> card.getAsString().equals("S12"));
     }
 
     /**

src/main/java/edu/ntnu/idatt1002/callumg/client/CardGameController.java

@@ -59,7 +59,7 @@ public class CardGameController implements Initializable {
     void checkHand() {
         HandOfCards handOfCards = new HandOfCards(currentDeck);
         StringBuilder sumOfCardsString = new StringBuilder("Sum: ");
-        sumOfCardsString.append(handOfCards.sumOfCards());
+        sumOfCardsString.append(handOfCards.getSumOfCards());
         sumofcards.setText(sumOfCardsString.toString());
 
         String hearts = "No heart cards";

src/test/java/edu/ntnu/idatt1002/callumg/DeckOfCardsTest.java

+package edu.ntnu.idatt1002.callumg;
+
+import edu.ntnu.idatt1002.callumg.cards.DeckOfCards;
+import edu.ntnu.idatt1002.callumg.cards.PlayingCard;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class DeckOfCardsTest {
+    @Nested
+    class testDealHandExceptions {
+        @Test
+        void testCannotDealEmptyOrNegativeHand() {
+            DeckOfCards deckOfCards = new DeckOfCards();
+            try {
+                deckOfCards.dealHand(0);
+                fail();
+            } catch (IllegalArgumentException e) {
+                assertEquals("You cannot deal 0 or less cards.", e.getMessage());
+            }
+        }
+        @Test
+        void testCannotDealMoreCardsThanInDeck() {
+            DeckOfCards deckOfCards = new DeckOfCards();
+            try {
+                deckOfCards.dealHand(53);
+                fail();
+            } catch (IllegalArgumentException e) {
+                assertEquals("You cannot deal more cards than are in the deck.", e.getMessage());
+            }
+        }
+    }
+
+    @Nested
+    class testDealHand {
+        @Test
+        void testDealtHandDoesNotContainDuplicates() {
+            DeckOfCards deckOfCards = new DeckOfCards();
+            ArrayList<PlayingCard> dealtHand = null;
+            try {
+                dealtHand = deckOfCards.dealHand(52);
+            } catch (IllegalArgumentException e) {
+                fail();
+            }
+            assertTrue(dealtHand.containsAll(deckOfCards.getCards()) && deckOfCards.getCards().containsAll(dealtHand));
+        }
+        @Test
+        void testDealtHandIsCorrectSize() {
+            DeckOfCards deckOfCards = new DeckOfCards();
+            ArrayList<PlayingCard> dealtHand1 = null;
+            ArrayList<PlayingCard> dealtHand2 = null;
+            ArrayList<PlayingCard> dealtHand3 = null;
+            try {
+                dealtHand1 = deckOfCards.dealHand(10);
+            } catch (IllegalArgumentException e) {
+                fail();
+            }
+            try {
+                dealtHand2 = deckOfCards.dealHand(12);
+            } catch (IllegalArgumentException e) {
+                fail();
+            }
+            try {
+                dealtHand3 = deckOfCards.dealHand(1);
+            } catch (IllegalArgumentException e) {
+                fail();
+            }
+            assertEquals(10, dealtHand1.size());
+            assertEquals(12, dealtHand2.size());
+            assertEquals(1, dealtHand3.size());
+        }
+    }
+}

src/test/java/edu/ntnu/idatt1002/callumg/HandOfCardsTest.java

+package edu.ntnu.idatt1002.callumg;
+
+import edu.ntnu.idatt1002.callumg.cards.HandOfCards;
+import edu.ntnu.idatt1002.callumg.cards.PlayingCard;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class HandOfCardsTest {
+    @Nested
+    class getHeartCards {
+        @Test
+        void testGetHeartCardsReturnsEmptyListWhenNoHeartCardsArePresent() {
+            ArrayList<PlayingCard> cards = new ArrayList<>();
+            cards.add(new PlayingCard('S', 8));
+            HandOfCards handOfCards = new HandOfCards(cards);
+            assertEquals(new ArrayList<>(), handOfCards.getHeartCards());
+        }
+        @Test
+        void testGetHeartCardsReturnsCorrectAmount() {
+            ArrayList cards = new ArrayList<>();
+            cards.add(new PlayingCard('S', 8));
+            cards.add(new PlayingCard('H', 4));
+            cards.add(new PlayingCard('H', 5));
+            cards.add(new PlayingCard('H', 6));
+            HandOfCards handOfCards = new HandOfCards(cards);
+            assertEquals(3, handOfCards.getHeartCards().size());
+        }
+    }
+
+    @Nested
+    class getSumOfCards {
+        @Test
+        void testGetSumOfCardsReturnsCorrectValue() {
+            ArrayList cards = new ArrayList<>();
+            cards.add(new PlayingCard('S', 8));
+            cards.add(new PlayingCard('H', 4));
+            cards.add(new PlayingCard('H', 5));
+            cards.add(new PlayingCard('H', 6));
+            HandOfCards handOfCards = new HandOfCards(cards);
+            assertEquals(23, handOfCards.getSumOfCards());
+        }
+        @Test
+        void testGetSumOfCardsWhenNoCardsOnHand() {
+            HandOfCards handOfCards = new HandOfCards(new ArrayList<>());
+            assertEquals(0, handOfCards.getSumOfCards());
+        }
+    }
+
+    @Nested
+    class deckContainsQueenOfSpades {
+        @Test
+        void testContainsQueenOfSpadesReturnsTrueWhenHandHasQueenOfSpades() {
+            ArrayList cards = new ArrayList<>();
+            cards.add(new PlayingCard('S', 8));
+            cards.add(new PlayingCard('H', 4));
+            cards.add(new PlayingCard('H', 5));
+            cards.add(new PlayingCard('H', 6));
+            cards.add(new PlayingCard('S', 12));
+            HandOfCards handOfCards = new HandOfCards(cards);
+            assertTrue(handOfCards.containsQueenOfSpades());
+        }
+        @Test
+        void testContainsQueenOfSpadesReturnsFalseWhenHandHasNotGotQueenOfSpades() {
+            ArrayList cards = new ArrayList<>();
+            cards.add(new PlayingCard('S', 8));
+            cards.add(new PlayingCard('H', 4));
+            cards.add(new PlayingCard('H', 5));
+            cards.add(new PlayingCard('H', 6));
+            cards.add(new PlayingCard('S', 13));
+            HandOfCards handOfCards = new HandOfCards(cards);
+            assertFalse(handOfCards.containsQueenOfSpades());
+        }
+    }
+
+    @Nested
+    class handIsFlush {
+        @Test
+        void testHandIsFlushReturnsTrueWhenHandIsFlush() {
+            ArrayList cards = new ArrayList<>();
+            cards.add(new PlayingCard('H', 8));
+            cards.add(new PlayingCard('H', 4));
+            cards.add(new PlayingCard('H', 5));
+            cards.add(new PlayingCard('H', 6));
+            cards.add(new PlayingCard('H', 13));
+            HandOfCards handOfCards = new HandOfCards(cards);
+            assertTrue(handOfCards.handIsFlush());
+        }
+        @Test
+        void testHandIsFlushReturnsFalseWhenHandIsNotFlush() {
+            ArrayList cards = new ArrayList<>();
+            cards.add(new PlayingCard('H', 8));
+            cards.add(new PlayingCard('H', 4));
+            cards.add(new PlayingCard('H', 5));
+            cards.add(new PlayingCard('H', 6));
+            cards.add(new PlayingCard('S', 13));
+            HandOfCards handOfCards = new HandOfCards(cards);
+            assertFalse(handOfCards.handIsFlush());
+        }
+    }
+}