diff --git a/PokerKata/src/session3/Card.java b/PokerKata/src/session3/Card.java new file mode 100644 index 0000000..9bf841b --- /dev/null +++ b/PokerKata/src/session3/Card.java @@ -0,0 +1,22 @@ +package session3; + +public class Card { + + private int value; + private String card; + + public Card(String cardAsString) { + this.card = cardAsString; + this.value = "23456789TJQKA".indexOf(cardAsString.substring(0,1)) + 2; + } + + public int getValue() { + return value; + } + + @Override + public String toString() { + return card; + } + +} diff --git a/PokerKata/src/session3/HighCardRule.java b/PokerKata/src/session3/HighCardRule.java new file mode 100644 index 0000000..0b2ed6f --- /dev/null +++ b/PokerKata/src/session3/HighCardRule.java @@ -0,0 +1,31 @@ +package session3; + +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +public class HighCardRule { + + public static Player compare(Player player1, Player player2) { + // Hands to lists + List playerHand1 = player1.getPlayerHand(); + List playerHand2 = player2.getPlayerHand(); + + PokerGameComparator comparator = new PokerGameComparator(); + Collections.sort(playerHand1, comparator); + Collections.sort(playerHand2, comparator); + + for (int i = 0; i < playerHand1.size(); i++) { + int p1Value = playerHand1.get(i).getValue(); + int p2Value = playerHand2.get(i).getValue(); + if (p1Value > p2Value) { + return player1; + } + if (p2Value > p1Value) { + return player2; + } + } + return null; + } + +} diff --git a/PokerKata/src/session3/PairRule.java b/PokerKata/src/session3/PairRule.java new file mode 100644 index 0000000..ed80539 --- /dev/null +++ b/PokerKata/src/session3/PairRule.java @@ -0,0 +1,46 @@ +package session3; + +import java.util.Collections; + +public class PairRule { + + public static Player compare(Player left, Player right) { +// if (playerHasPair(left)) { +// return left; +// } +// if (playerHasPair(right)) { +// return right; +// } + + int pairValueLeft = getValueOfPairForPlayer(left); + int pairValueRight = getValueOfPairForPlayer(right); + + if (pairValueLeft > pairValueRight) { + return left; + } + + if (pairValueRight > pairValueLeft) { + return right; + } + + return null; + } + + private static int getValueOfPairForPlayer(Player left) { + PokerGameComparator comparator = new PokerGameComparator(); + Collections.sort(left.getPlayerHand(), comparator); + int cardValue=0; + + for (Card card : left.getPlayerHand()) { + if (card.getValue() == cardValue){ + return card.getValue(); + } + else{ + cardValue= card.getValue(); + } + + } + return 0; + } + +} diff --git a/PokerKata/src/session3/Player.java b/PokerKata/src/session3/Player.java new file mode 100644 index 0000000..522c748 --- /dev/null +++ b/PokerKata/src/session3/Player.java @@ -0,0 +1,28 @@ +package session3; + +import java.util.ArrayList; +import java.util.List; + +public class Player { + + private String name; + private ArrayList cards; + + public Player(String name, String cards) { + this.name = name; + this.cards = new ArrayList(); + String[] split = cards.split(" "); + for (String val : split) { + this.cards.add(new Card(val)); + } + } + + public String getPlayerName() { + return name; + } + + public List getPlayerHand() { + return this.cards; + } + +} diff --git a/PokerKata/src/session3/PokerGame.java b/PokerKata/src/session3/PokerGame.java index ff715b9..5322118 100644 --- a/PokerKata/src/session3/PokerGame.java +++ b/PokerKata/src/session3/PokerGame.java @@ -1,14 +1,6 @@ -/** - * PokerGame.java - * - * Course in Software Craftsmenship @ Högskolan Väst - * Poker game kata for testing TDD, Test Driven Development - * - * 2015-04-27 - */ - package session3; +<<<<<<< HEAD import java.util.Arrays; /** @@ -268,10 +260,23 @@ public class PokerGame { // Find all values for (int i = 0; i < hand.length() - 1; i += 2) { temp += hand.charAt(i); +======= +public class PokerGame { + + public Player calculateWinningPlayer(Player left, Player right) { + + Player twoPairResult = TwoPairRule.compare(left, right); + if(twoPairResult != null){ + return twoPairResult; } - colors = temp.toCharArray(); - Arrays.sort(colors); - return colors; + + Player pairResult = PairRule.compare(left, right); + if(pairResult != null){ + return pairResult; +>>>>>>> origin/master + } + + return HighCardRule.compare(left, right); } } diff --git a/PokerKata/src/session3/PokerGameComparator.java b/PokerKata/src/session3/PokerGameComparator.java new file mode 100644 index 0000000..ea3a2e0 --- /dev/null +++ b/PokerKata/src/session3/PokerGameComparator.java @@ -0,0 +1,12 @@ +package session3; + +import java.util.Comparator; + +public class PokerGameComparator implements Comparator { + + @Override + public int compare(Card arg0, Card arg1) { + return arg1.getValue() - arg0.getValue(); + } + +} diff --git a/PokerKata/src/session3/TwoPairRule.java b/PokerKata/src/session3/TwoPairRule.java new file mode 100644 index 0000000..3c2267c --- /dev/null +++ b/PokerKata/src/session3/TwoPairRule.java @@ -0,0 +1,67 @@ +package session3; + +import java.util.Collections; + +public class TwoPairRule { + + private static final int[] noPairs = { 0, 0 }; + + public static Player compare(Player left, Player right) { + int[] pairsLeft = getValuesForTwoPair(left); + int[] pairsRight = getValuesForTwoPair(right); + + for (int i = 0; i < 2; i++) { + int pairValueLeft = pairsLeft[i]; + int pairValueRight = pairsRight[i]; + + if (pairValueLeft > pairValueRight) { + return left; + } + if (pairValueRight > pairValueLeft) { + return right; + } + } + + return null; + } + + private static int[] getValuesForTwoPair(Player player) { + if (!playerHasTwoPair(player)) { + return noPairs; + } + PokerGameComparator comparator = new PokerGameComparator(); + Collections.sort(player.getPlayerHand(), comparator); + int[] cardValues = new int[2]; + int pairCount = 0; + + for (Card card : player.getPlayerHand()) { + if (card.getValue() == cardValues[pairCount]) { + cardValues[pairCount++] = card.getValue(); + } else { + cardValues[pairCount] = card.getValue(); + } + } + return cardValues; + } + + private static boolean playerHasTwoPair(Player player) { + PokerGameComparator comparator = new PokerGameComparator(); + Collections.sort(player.getPlayerHand(), comparator); + int cardValue = 0; + int pairCount = 0; + + for (Card card : player.getPlayerHand()) { + if (card.getValue() == cardValue) { + pairCount++; + } else { + cardValue = card.getValue(); + } + } + + if (pairCount == 2) { + return true; + } + return false; + } + +} diff --git a/PokerKata/test/session3/CardTest.java b/PokerKata/test/session3/CardTest.java new file mode 100644 index 0000000..336c926 --- /dev/null +++ b/PokerKata/test/session3/CardTest.java @@ -0,0 +1,24 @@ +package session3; + +import static org.junit.Assert.*; + +import org.junit.Test; + +public class CardTest { + + @Test + public void give_me_a_card() { + Card card = new Card("4H"); + assertEquals(4, card.getValue()); + } + + @Test + public void test_suited_values() throws Exception { + assertEquals(10, new Card("TD").getValue()); + assertEquals(11, new Card("JD").getValue()); + assertEquals(12, new Card("QD").getValue()); + assertEquals(13, new Card("KD").getValue()); + assertEquals(14, new Card("AD").getValue()); + } + +} diff --git a/PokerKata/test/session3/HighCardRuleTest.java b/PokerKata/test/session3/HighCardRuleTest.java new file mode 100644 index 0000000..37de5e9 --- /dev/null +++ b/PokerKata/test/session3/HighCardRuleTest.java @@ -0,0 +1,50 @@ +package session3; + +import static org.junit.Assert.*; + +import org.junit.Ignore; +import org.junit.Test; + +public class HighCardRuleTest { + + @Test + public void check_High_Card_one_card_per_hand() { + Player player1 = new Player("Anna", "9H"); + Player player2 = new Player("Kalle", "4H"); + + Player winner = HighCardRule.compare(player1, player2); + + assertEquals("Anna", winner.getPlayerName()); + } + + @Test + public void same_cards_returns_tie() throws Exception { + Player player1 = new Player("1", "2H"); + Player player2 = new Player("2", "2C"); + + Player winner = HighCardRule.compare(player1, player2); + + assertNull(winner); + } + + @Test + public void check_high_card_multiple_cards_per_hand() throws Exception { + Player player1 = new Player("Anna", "4H 4D"); + Player player2 = new Player("Kalle", "4C 5C"); + + Player winner = HighCardRule.compare(player1, player2); + + assertEquals("Kalle", winner.getPlayerName()); + } + + @Test + public void check_high_card_multiple_cards_per_hand_one_differs() throws Exception { + Player player1 = new Player("Anna", "3H 5D 6H 8D 9C"); + Player player2 = new Player("Kalle", "4C 5C 6D 9D 8H"); + + Player winner = HighCardRule.compare(player1, player2); + + assertEquals("Kalle", winner.getPlayerName()); + } + +} diff --git a/PokerKata/test/session3/PairRuleTest.java b/PokerKata/test/session3/PairRuleTest.java new file mode 100644 index 0000000..b570a24 --- /dev/null +++ b/PokerKata/test/session3/PairRuleTest.java @@ -0,0 +1,40 @@ +package session3; + +import static org.junit.Assert.*; + +import org.junit.Test; + +public class PairRuleTest { + + @Test + public void pair_wins_over_high_card() { + Player green = new Player("Green", "2S 3C 4D 7H AH"); + Player white = new Player("White", "3S 3C 5D 6H KH"); + + Player winningPlayer = PairRule.compare(green, white); + + assertEquals("White", winningPlayer.getPlayerName()); + } + @Test + public void higher_pair_wins_over_lower_pair() throws Exception { + + Player white = new Player("White", "2S 3C 7D 7H AH"); + Player green = new Player("Green", "3S 3C 5D 6H KH"); + + Player winningPlayer = PairRule.compare(green, white); + + assertEquals("White", winningPlayer.getPlayerName()); + + } + + @Test + public void test_if_pair_is_tie() throws Exception { + Player white = new Player("White", "2S 3C 7D 7H AH"); + Player green = new Player("Green", "7S 7C 5D 6H KH"); + + Player winningPlayer = PairRule.compare(green, white); + + assertNull(winningPlayer); + } + +} diff --git a/PokerKata/test/session3/PlayerTest.java b/PokerKata/test/session3/PlayerTest.java new file mode 100644 index 0000000..c8d1339 --- /dev/null +++ b/PokerKata/test/session3/PlayerTest.java @@ -0,0 +1,52 @@ +package session3; + +import static org.junit.Assert.*; + +import java.util.ArrayList; +import java.util.List; + +import org.junit.Ignore; +import org.junit.Test; + +public class PlayerTest { + + @Test + public void getPlayerName() { + assertEquals("Christian", new Player("Christian", "5H").getPlayerName()); + } + + @Test + public void getPlayerHand() throws Exception { + List listCard = new ArrayList(); + listCard.add(new Card("5H")); + Player player = new Player("bob", "5H"); + + List result = player.getPlayerHand(); + + assertEquals(listCard.get(0).getValue(), result.get(0).getValue()); + } + + @Test + public void constructor_handles_multiple_cards() throws Exception { + List listCard = new ArrayList(); + listCard.add(new Card("5H")); + listCard.add(new Card("3H")); + Player player = new Player("bob", "5H 3H"); + + List result = player.getPlayerHand(); + + assertEquals(listCard.size(), result.size()); + } + + @Test + public void constructor_handles_multiple_cards_suit_cards() throws Exception { + List listCard = new ArrayList(); + listCard.add(new Card("5H")); + listCard.add(new Card("3H")); + Player player = new Player("bob", "5H 3H"); + + List result = player.getPlayerHand(); + + assertEquals(listCard.size(), result.size()); + } +} diff --git a/PokerKata/test/session3/PokerGameComparatorTest.java b/PokerKata/test/session3/PokerGameComparatorTest.java new file mode 100644 index 0000000..1b4e649 --- /dev/null +++ b/PokerKata/test/session3/PokerGameComparatorTest.java @@ -0,0 +1,28 @@ +package session3; + +import static org.junit.Assert.assertEquals; + +import java.util.Arrays; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + +import org.junit.Test; + +public class PokerGameComparatorTest { + + @Test + public void test_sort_by_value() { + + List originalList = Arrays.asList(new Card("3H"), new Card("5H"), new Card("2H")); + + PokerGameComparator comparator = new PokerGameComparator(); + Collections.sort(originalList, comparator); + + assertEquals(5, originalList.get(0).getValue()); + assertEquals(3, originalList.get(1).getValue()); + assertEquals(2, originalList.get(2).getValue()); + + } + +} diff --git a/PokerKata/test/session3/PokerGameTest.java b/PokerKata/test/session3/PokerGameTest.java index ebe0bbd..4b67e7d 100644 --- a/PokerKata/test/session3/PokerGameTest.java +++ b/PokerKata/test/session3/PokerGameTest.java @@ -1,20 +1,12 @@ -/** - * PokerGame.java - * - * Course in Software Craftsmenship @ Högskolan Väst - * Poker game kata for testing TDD, Test Driven Development - * - * 2015-04-27 - */ - package session3; -import static org.junit.Assert.assertEquals; +import static org.junit.Assert.*; import org.junit.Ignore; import org.junit.Test; public class PokerGameTest { +<<<<<<< HEAD PokerGame myGame = new PokerGame(); @Test @@ -47,9 +39,18 @@ public class PokerGameTest { @Test public void three_of_a_kind_gives_3() throws Exception { String hand = "S8H8C8D3S4"; +======= - int result = myGame.getScore(hand); + @Test + public void green_wins_with_highest_card() { + Player green = new Player("Green", "2S 3C 4D 7H AH"); + Player white = new Player("White", "3S 4C 5D 6H KH"); + PokerGame game = new PokerGame(); +>>>>>>> origin/master + Player winningPlayer = game.calculateWinningPlayer(green, white); + +<<<<<<< HEAD assertEquals(3, result); } @@ -61,9 +62,24 @@ public class PokerGameTest { int result = myGame.getScore(hand); assertEquals(4, result); +======= + assertEquals("Green", winningPlayer.getPlayerName()); } @Test + public void one_pair_beats_highest_card() throws Exception { + Player green = new Player("Green", "2S 3C 4D 7H AH"); + Player white = new Player("White", "3S 3C 5D 6H KH"); + PokerGame game = new PokerGame(); + + Player winningPlayer = game.calculateWinningPlayer(green, white); + + assertEquals("White", winningPlayer.getPlayerName()); +>>>>>>> origin/master + } + + @Test +<<<<<<< HEAD @Ignore public void flush_gives_5() throws Exception { String hand = "S2S6S7S8S9"; @@ -111,5 +127,15 @@ public class PokerGameTest { int result = myGame.getScore(hand); assertEquals(9, result); +======= + public void two_pair_beats_one_pair() throws Exception { + Player green = new Player("Green", "6S 6C 4D 7H AH"); + Player white = new Player("White", "3S 3C 5D 5H KH"); + PokerGame game = new PokerGame(); + + Player winningPlayer = game.calculateWinningPlayer(green, white); + + assertEquals("White", winningPlayer.getPlayerName()); +>>>>>>> origin/master } -} \ No newline at end of file +} diff --git a/PokerKata/test/session3/TwoPairRuleTest.java b/PokerKata/test/session3/TwoPairRuleTest.java new file mode 100644 index 0000000..2ba7ac5 --- /dev/null +++ b/PokerKata/test/session3/TwoPairRuleTest.java @@ -0,0 +1,39 @@ +package session3; + +import src.session3.Player; +import src.session3.TwoPairRule; + +public class TwoPairRuleTest { + + @Test + public void two_pair_wins_over_pair() { + Player green = new Player("Green", "6S 6C 4D 7H AH"); + Player white = new Player("White", "3S 3C 5D 5H KH"); + + Player winningPlayer = TwoPairRule.compare(green, white); + + assertEquals("White", winningPlayer.getPlayerName()); + } + + @Test + public void higher_two_pair_wins_over_lower_two_pair() throws Exception { + + Player green = new Player("Green", "4S 4C 6D 6H AH"); + Player white = new Player("White", "3S 3C 5D 5H KH"); + + Player winningPlayer = TwoPairRule.compare(white, green); + + assertEquals("Green", winningPlayer.getPlayerName()); + + } + + @Test + public void first_pair_tie_second_pair_highest_wins() throws Exception { + Player green = new Player("Green", "9S 9C 6D 6H AH"); + Player white = new Player("White", "9H 9D 5D 5H KH"); + + Player winningPlayer = TwoPairRule.compare(white, green); + + assertEquals("Green", winningPlayer.getPlayerName()); + } +} diff --git a/README.md b/README.md index 926eacb..1248f82 100644 --- a/README.md +++ b/README.md @@ -68,6 +68,26 @@ Inom WhiteBox-test har man möjligheten att kunna titta in i lådan för att se ## 3. Test Double Inför detta pas gjorde vi som hemarbete den tredje katan, Poker Kata +Nu skall den göras på riktigt. + +### Klassdiagram + +#### Kort +- Färg +- Värde + +#### Kortlek +- Kort +- Blanda + +#### Spelare +- 5 Kort + +#### Spel +- Kortlek +- Regler +- Spelare +- Jämför händer ## 4. Clean Code + ATDD