From 7ff5e12124aebe9255c7962ce6eb0ef49ceea9c1 Mon Sep 17 00:00:00 2001
From: Michael Hunteman <michael@huntm.net>
Date: Tue, 22 Nov 2022 14:07:43 -0600
Subject: Initial commit

---
 GameTest.java | 527 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 527 insertions(+)
 create mode 100644 GameTest.java

(limited to 'GameTest.java')

diff --git a/GameTest.java b/GameTest.java
new file mode 100644
index 0000000..4f67793
--- /dev/null
+++ b/GameTest.java
@@ -0,0 +1,527 @@
+import java.util.*;
+import static org.junit.Assert.assertEquals;
+import org.junit.Test;
+import card.*;
+
+public class GameTest {
+    @Test
+    public void testPair() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(1, Suit.CLUBS));
+        firstHand.add(new Card(1, Suit.HEARTS));
+        firstHand.add(new Card(2, Suit.DIAMONDS));
+        firstHand.add(new Card(3, Suit.SPADES));
+        firstHand.add(new Card(4, Suit.HEARTS));
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        assertEquals(Arrays.asList(1), ranks);
+    }
+
+    @Test
+    public void testTwoPair() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(1, Suit.CLUBS));
+        firstHand.add(new Card(1, Suit.HEARTS));
+        firstHand.add(new Card(2, Suit.DIAMONDS));
+        firstHand.add(new Card(2, Suit.SPADES));
+        firstHand.add(new Card(4, Suit.HEARTS));
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        assertEquals(Arrays.asList(2), ranks);
+    }
+
+    @Test
+    public void testThreeOfKind() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(1, Suit.CLUBS));
+        firstHand.add(new Card(1, Suit.HEARTS));
+        firstHand.add(new Card(1, Suit.DIAMONDS));
+        firstHand.add(new Card(2, Suit.SPADES));
+        firstHand.add(new Card(4, Suit.HEARTS));
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        assertEquals(Arrays.asList(3), ranks);
+    }
+
+    @Test
+    public void testStraight() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(1, Suit.CLUBS));
+        firstHand.add(new Card(2, Suit.HEARTS));
+        firstHand.add(new Card(3, Suit.DIAMONDS));
+        firstHand.add(new Card(4, Suit.SPADES));
+        firstHand.add(new Card(5, Suit.HEARTS));
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        assertEquals(Arrays.asList(4), ranks);
+    }
+
+    @Test
+    public void testFlush() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(1, Suit.HEARTS));
+        firstHand.add(new Card(7, Suit.HEARTS));
+        firstHand.add(new Card(3, Suit.HEARTS));
+        firstHand.add(new Card(9, Suit.HEARTS));
+        firstHand.add(new Card(12, Suit.HEARTS));
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        assertEquals(Arrays.asList(5), ranks);
+    }
+
+    @Test
+    public void testFullHouse() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(1, Suit.CLUBS));
+        firstHand.add(new Card(1, Suit.HEARTS));
+        firstHand.add(new Card(1, Suit.DIAMONDS));
+        firstHand.add(new Card(2, Suit.SPADES));
+        firstHand.add(new Card(2, Suit.HEARTS));
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        assertEquals(Arrays.asList(6), ranks);
+    }
+
+    @Test
+    public void testFourOfKind() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(1, Suit.CLUBS));
+        firstHand.add(new Card(1, Suit.HEARTS));
+        firstHand.add(new Card(1, Suit.DIAMONDS));
+        firstHand.add(new Card(1, Suit.SPADES));
+        firstHand.add(new Card(2, Suit.HEARTS));
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        assertEquals(Arrays.asList(7), ranks);
+    }
+
+    @Test
+    public void testStraightFlush() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(1, Suit.CLUBS));
+        firstHand.add(new Card(2, Suit.CLUBS));
+        firstHand.add(new Card(3, Suit.CLUBS));
+        firstHand.add(new Card(4, Suit.CLUBS));
+        firstHand.add(new Card(5, Suit.CLUBS));
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        assertEquals(Arrays.asList(8), ranks);
+    }
+
+    @Test
+    public void testRoyalFlush() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(1, Suit.CLUBS));
+        firstHand.add(new Card(10, Suit.CLUBS));
+        firstHand.add(new Card(11, Suit.CLUBS));
+        firstHand.add(new Card(12, Suit.CLUBS));
+        firstHand.add(new Card(13, Suit.CLUBS));
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        assertEquals(Arrays.asList(9), ranks);
+    }
+
+    @Test
+    public void testUnsortedPair() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(2, Suit.CLUBS));
+        firstHand.add(new Card(9, Suit.HEARTS));
+        firstHand.add(new Card(2, Suit.DIAMONDS));
+        firstHand.add(new Card(13, Suit.SPADES));
+        firstHand.add(new Card(6, Suit.CLUBS));
+        firstHand = g.sort(firstHand);
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        assertEquals(Arrays.asList(1), ranks);
+    }
+
+    @Test
+    public void testUnsortedTwoPair() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(2, Suit.CLUBS));
+        firstHand.add(new Card(4, Suit.CLUBS));
+        firstHand.add(new Card(2, Suit.SPADES));
+        firstHand.add(new Card(1, Suit.HEARTS));
+        firstHand.add(new Card(4, Suit.DIAMONDS));
+        firstHand = g.sort(firstHand);
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        assertEquals(Arrays.asList(2), ranks);
+    }
+
+    @Test
+    public void testUnsortedThreeOfKind() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(7, Suit.CLUBS));
+        firstHand.add(new Card(4, Suit.DIAMONDS));
+        firstHand.add(new Card(7, Suit.HEARTS));
+        firstHand.add(new Card(1, Suit.CLUBS));
+        firstHand.add(new Card(7, Suit.SPADES));
+        firstHand = g.sort(firstHand);
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        assertEquals(Arrays.asList(3), ranks);
+    }
+
+    @Test
+    public void testUnsortedStraight() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(7, Suit.CLUBS));
+        firstHand.add(new Card(4, Suit.HEARTS));
+        firstHand.add(new Card(6, Suit.SPADES));
+        firstHand.add(new Card(8, Suit.DIAMONDS));
+        firstHand.add(new Card(5, Suit.CLUBS));
+        firstHand = g.sort(firstHand);
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        assertEquals(Arrays.asList(4), ranks);
+    }
+
+    @Test
+    public void testUnsortedFlush() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(7, Suit.SPADES));
+        firstHand.add(new Card(2, Suit.SPADES));
+        firstHand.add(new Card(6, Suit.SPADES));
+        firstHand.add(new Card(11, Suit.SPADES));
+        firstHand.add(new Card(3, Suit.SPADES));
+        firstHand = g.sort(firstHand);
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        assertEquals(Arrays.asList(5), ranks);
+    }
+
+    @Test
+    public void testUnsortedFullHouse() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(4, Suit.CLUBS));
+        firstHand.add(new Card(8, Suit.HEARTS));
+        firstHand.add(new Card(4, Suit.DIAMONDS));
+        firstHand.add(new Card(8, Suit.SPADES));
+        firstHand.add(new Card(4, Suit.HEARTS));
+        firstHand = g.sort(firstHand);
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        assertEquals(Arrays.asList(6), ranks);
+    }
+
+    @Test
+    public void testUnsortedFourOfKind() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(1, Suit.CLUBS));
+        firstHand.add(new Card(1, Suit.HEARTS));
+        firstHand.add(new Card(2, Suit.DIAMONDS));
+        firstHand.add(new Card(1, Suit.SPADES));
+        firstHand.add(new Card(1, Suit.HEARTS));
+        firstHand = g.sort(firstHand);
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        assertEquals(Arrays.asList(7), ranks);
+    }
+
+    @Test
+    public void testUnsortedStraightFlush() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(2, Suit.CLUBS));
+        firstHand.add(new Card(4, Suit.CLUBS));
+        firstHand.add(new Card(3, Suit.CLUBS));
+        firstHand.add(new Card(1, Suit.CLUBS));
+        firstHand.add(new Card(5, Suit.CLUBS));
+        firstHand = g.sort(firstHand);
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        assertEquals(Arrays.asList(8), ranks);
+    }
+
+    @Test
+    public void testUnsortedRoyalFlush() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(11, Suit.CLUBS));
+        firstHand.add(new Card(13, Suit.CLUBS));
+        firstHand.add(new Card(10, Suit.CLUBS));
+        firstHand.add(new Card(1, Suit.CLUBS));
+        firstHand.add(new Card(12, Suit.CLUBS));
+        firstHand = g.sort(firstHand);
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        assertEquals(Arrays.asList(9), ranks);
+    }
+
+    @Test
+    public void highCardVsHighCard() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<Card> secondHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(11, Suit.CLUBS));
+        firstHand.add(new Card(3, Suit.DIAMONDS));
+        firstHand.add(new Card(8, Suit.SPADES));
+        firstHand.add(new Card(9, Suit.HEARTS));
+        firstHand.add(new Card(5, Suit.CLUBS));
+        firstHand = g.sort(firstHand);
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        secondHand.add(new Card(1, Suit.CLUBS));
+        secondHand.add(new Card(3, Suit.SPADES));
+        secondHand.add(new Card(9, Suit.SPADES));
+        secondHand.add(new Card(7, Suit.DIAMONDS));
+        secondHand.add(new Card(5, Suit.HEARTS));
+        secondHand = g.sort(secondHand);
+        hands.add(secondHand);
+        ranks.add(g.getRank(secondHand));
+        g.setHands(hands);
+        g.setRanks(ranks);
+        assertEquals(1, g.getWinner());
+    }
+
+    @Test
+    public void highCardVsPair() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<Card> secondHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(11, Suit.CLUBS));
+        firstHand.add(new Card(3, Suit.DIAMONDS));
+        firstHand.add(new Card(8, Suit.SPADES));
+        firstHand.add(new Card(9, Suit.HEARTS));
+        firstHand.add(new Card(5, Suit.CLUBS));
+        firstHand = g.sort(firstHand);
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        secondHand.add(new Card(4, Suit.CLUBS));
+        secondHand.add(new Card(3, Suit.SPADES));
+        secondHand.add(new Card(9, Suit.SPADES));
+        secondHand.add(new Card(9, Suit.DIAMONDS));
+        secondHand.add(new Card(5, Suit.HEARTS));
+        secondHand = g.sort(secondHand);
+        hands.add(secondHand);
+        ranks.add(g.getRank(secondHand));
+        g.setHands(hands);
+        g.setRanks(ranks);
+        assertEquals(1, g.getWinner());
+    }
+
+    @Test
+    public void pairVsPair() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<Card> secondHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(1, Suit.CLUBS));
+        firstHand.add(new Card(13, Suit.DIAMONDS));
+        firstHand.add(new Card(5, Suit.SPADES));
+        firstHand.add(new Card(6, Suit.DIAMONDS));
+        firstHand.add(new Card(5, Suit.CLUBS));
+        firstHand = g.sort(firstHand);
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        secondHand.add(new Card(11, Suit.HEARTS));
+        secondHand.add(new Card(2, Suit.CLUBS));
+        secondHand.add(new Card(12, Suit.HEARTS));
+        secondHand.add(new Card(9, Suit.SPADES));
+        secondHand.add(new Card(12, Suit.CLUBS));
+        secondHand = g.sort(secondHand);
+        hands.add(secondHand);
+        ranks.add(g.getRank(secondHand));
+        g.setHands(hands);
+        g.setRanks(ranks);
+        assertEquals(1, g.getWinner());
+    }
+
+    @Test
+    public void pairVsTwoPair() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<Card> secondHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(11, Suit.CLUBS));
+        firstHand.add(new Card(3, Suit.DIAMONDS));
+        firstHand.add(new Card(8, Suit.SPADES));
+        firstHand.add(new Card(9, Suit.HEARTS));
+        firstHand.add(new Card(8, Suit.CLUBS));
+        firstHand = g.sort(firstHand);
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        secondHand.add(new Card(4, Suit.CLUBS));
+        secondHand.add(new Card(3, Suit.SPADES));
+        secondHand.add(new Card(9, Suit.SPADES));
+        secondHand.add(new Card(9, Suit.DIAMONDS));
+        secondHand.add(new Card(3, Suit.HEARTS));
+        secondHand = g.sort(secondHand);
+        hands.add(secondHand);
+        ranks.add(g.getRank(secondHand));
+        g.setHands(hands);
+        g.setRanks(ranks);
+        assertEquals(1, g.getWinner());
+    }
+
+    @Test
+    public void twoPairVsTwoPair() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<Card> secondHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(1, Suit.CLUBS));
+        firstHand.add(new Card(8, Suit.SPADES));
+        firstHand.add(new Card(6, Suit.SPADES));
+        firstHand.add(new Card(8, Suit.HEARTS));
+        firstHand.add(new Card(6, Suit.CLUBS));
+        firstHand = g.sort(firstHand);
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        secondHand.add(new Card(12, Suit.HEARTS));
+        secondHand.add(new Card(9, Suit.CLUBS));
+        secondHand.add(new Card(9, Suit.SPADES));
+        secondHand.add(new Card(2, Suit.SPADES));
+        secondHand.add(new Card(12, Suit.DIAMONDS));
+        secondHand = g.sort(secondHand);
+        hands.add(secondHand);
+        ranks.add(g.getRank(secondHand));
+        g.setHands(hands);
+        g.setRanks(ranks);
+        assertEquals(1, g.getWinner());
+    }
+
+    @Test
+    public void threeOfKindVsThreeOfKind() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<Card> secondHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(11, Suit.CLUBS));
+        firstHand.add(new Card(2, Suit.CLUBS));
+        firstHand.add(new Card(11, Suit.SPADES));
+        firstHand.add(new Card(13, Suit.SPADES));
+        firstHand.add(new Card(11, Suit.DIAMONDS));
+        firstHand = g.sort(firstHand);
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        secondHand.add(new Card(9, Suit.HEARTS));
+        secondHand.add(new Card(12, Suit.CLUBS));
+        secondHand.add(new Card(8, Suit.HEARTS));
+        secondHand.add(new Card(12, Suit.HEARTS));
+        secondHand.add(new Card(12, Suit.SPADES));
+        secondHand = g.sort(secondHand);
+        hands.add(secondHand);
+        ranks.add(g.getRank(secondHand));
+        g.setHands(hands);
+        g.setRanks(ranks);
+        assertEquals(1, g.getWinner());
+    }
+
+    @Test
+    public void fullHouseVsfullHouse() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<Card> secondHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(11, Suit.CLUBS));
+        firstHand.add(new Card(11, Suit.HEARTS));
+        firstHand.add(new Card(11, Suit.SPADES));
+        firstHand.add(new Card(5, Suit.SPADES));
+        firstHand.add(new Card(5, Suit.DIAMONDS));
+        firstHand = g.sort(firstHand);
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        secondHand.add(new Card(12, Suit.HEARTS));
+        secondHand.add(new Card(12, Suit.CLUBS));
+        secondHand.add(new Card(8, Suit.HEARTS));
+        secondHand.add(new Card(12, Suit.DIAMONDS));
+        secondHand.add(new Card(8, Suit.SPADES));
+        secondHand = g.sort(secondHand);
+        hands.add(secondHand);
+        ranks.add(g.getRank(secondHand));
+        g.setHands(hands);
+        g.setRanks(ranks);
+        assertEquals(1, g.getWinner());
+	}
+
+    @Test
+    public void fourOfKindVsfourOfKind() {
+        Game g = new Game();
+        List<Card> firstHand = new ArrayList<>();
+        List<Card> secondHand = new ArrayList<>();
+        List<List<Card>> hands = new ArrayList<>();
+        List<Integer> ranks = new ArrayList<>();
+        firstHand.add(new Card(11, Suit.CLUBS));
+        firstHand.add(new Card(11, Suit.HEARTS));
+        firstHand.add(new Card(11, Suit.SPADES));
+        firstHand.add(new Card(13, Suit.SPADES));
+        firstHand.add(new Card(11, Suit.DIAMONDS));
+        firstHand = g.sort(firstHand);
+        hands.add(firstHand);
+        ranks.add(g.getRank(firstHand));
+        secondHand.add(new Card(12, Suit.HEARTS));
+        secondHand.add(new Card(12, Suit.CLUBS));
+        secondHand.add(new Card(8, Suit.HEARTS));
+        secondHand.add(new Card(12, Suit.DIAMONDS));
+        secondHand.add(new Card(12, Suit.SPADES));
+        secondHand = g.sort(secondHand);
+        hands.add(secondHand);
+        ranks.add(g.getRank(secondHand));
+        g.setHands(hands);
+        g.setRanks(ranks);
+        assertEquals(1, g.getWinner());
+	}
+}
-- 
cgit v1.2.3