From b6bc87d511ef96e5cbe58ad38d7368de36521c1c Mon Sep 17 00:00:00 2001 From: di7chro Date: Wed, 29 Apr 2015 09:16:27 +0200 Subject: [PATCH] New version Made in thge sessions --- PokerKata/src/session3/Card.java | 22 ++ PokerKata/src/session3/HighCardRule.java | 31 +++ PokerKata/src/session3/PairRule.java | 46 +++++ PokerKata/src/session3/Player.java | 28 +++ PokerKata/src/session3/PokerGame.java | 193 +----------------- .../src/session3/PokerGameComparator.java | 12 ++ PokerKata/src/session3/TwoPairRule.java | 67 ++++++ PokerKata/test/session3/CardTest.java | 24 +++ PokerKata/test/session3/HighCardRuleTest.java | 50 +++++ PokerKata/test/session3/PairRuleTest.java | 40 ++++ PokerKata/test/session3/PlayerTest.java | 52 +++++ .../session3/PokerGameComparatorTest.java | 28 +++ PokerKata/test/session3/PokerGameTest.java | 85 +++----- PokerKata/test/session3/TwoPairRuleTest.java | 40 ++++ 14 files changed, 474 insertions(+), 244 deletions(-) create mode 100644 PokerKata/src/session3/Card.java create mode 100644 PokerKata/src/session3/HighCardRule.java create mode 100644 PokerKata/src/session3/PairRule.java create mode 100644 PokerKata/src/session3/Player.java create mode 100644 PokerKata/src/session3/PokerGameComparator.java create mode 100644 PokerKata/src/session3/TwoPairRule.java create mode 100644 PokerKata/test/session3/CardTest.java create mode 100644 PokerKata/test/session3/HighCardRuleTest.java create mode 100644 PokerKata/test/session3/PairRuleTest.java create mode 100644 PokerKata/test/session3/PlayerTest.java create mode 100644 PokerKata/test/session3/PokerGameComparatorTest.java create mode 100644 PokerKata/test/session3/TwoPairRuleTest.java 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 afdf76e..92587ee 100644 --- a/PokerKata/src/session3/PokerGame.java +++ b/PokerKata/src/session3/PokerGame.java @@ -1,191 +1,20 @@ -/** - * 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 java.util.Arrays; - -/** - * Gives you a score with a hand of poker - * - * @author crille - * - */ public class PokerGame { - public int getScore(String hand) { - int score = 0; - if (findFlush(hand) == true) - score = 10; - else if (findFullHouse(hand) == true) - score = 9; - else if (findFourOfAKind(hand) == true) - score = 7; - else if (findTwoPairs(hand) == true) - score = 6; - else if (findThreeOfAKind(hand) == true) - score = 3; - else if (findPair(hand) == true) - score = 2; - else - score = 0; - return score; - } - - /** - * Finds a pair by looking if two cards next to each other has the same - * value - * - * @param hand - * @return true if there is a pair, otherwise false - */ - private boolean findPair(String hand) { - char[] values = getValues(hand); - - // Loop again, find pair - for (int i = 0; i < values.length - 1; i++) { - if (values[i] == values[i + 1]) - return true; + public Player calculateWinningPlayer(Player left, Player right) { + + Player twoPairResult = TwoPairRule.compare(left, right); + if(twoPairResult != null){ + return twoPairResult; } - return false; - } - - /** - * Finds a pair by looking if three cards next to each other has the same - * value - * - * @param hand - * @return true if there is a Three of a kind, otherwise false - */ - private boolean findThreeOfAKind(String hand) { - char[] values = getValues(hand); - - // Loop again, find three of a kind - for (int i = 0; i < values.length - 2; i++) { - if (values[i] == values[i + 1] && values[i + 1] == values[i + 2]) - return true; + + Player pairResult = PairRule.compare(left, right); + if(pairResult != null){ + return pairResult; } - return false; + + return HighCardRule.compare(left, right); } - /** - * Finds two pairs by looking for a pair, and them look if the remaining - * cards is a pair - * - * @param hand - * @return true if there is two pairs, otherwise false - */ - private boolean findTwoPairs(String hand) { - char[] values = getValues(hand); - - try { - // Loop again, find pair - for (int i = 0; i < values.length - 1; i++) { - if (values[i] == values[i + 1]) { - if (values[i + 2] == values[i + 3] - || values[i + 3] == values[i + 4]) { - return true; - } - } - } - } catch (ArrayIndexOutOfBoundsException e) { - return false; - } - return false; - } - - /** - * Finds Four of a kind by first finding Three of a kind and then looks if - * one of the remaining cards matches - * - * @param hand - * @return true if there is a Four of a kind, otherwise false - */ - private boolean findFourOfAKind(String hand) { - char[] values = getValues(hand); - - // Loop again, find three of a kind - for (int i = 0; i < values.length - 2; i++) { - if (values[i] == values[i + 1] && values[i + 1] == values[i + 2] - && values[i + 2] == values[i + 3]) - return true; - } - return false; - } - - /** - * Finds a Full house. We have a Full House if the first and last two cards - * are a pair, and the middle card has same value as either of them (is - * three of a kind) - * - * @param hand - * @return true if there is a Full House, otherwise false - */ - private boolean findFullHouse(String hand) { - char[] values = getValues(hand); - - if (values[0] == values[1] && values[3] == values[4] - && (values[0] == values[2] || values[2] == values[3])) - return true; - return false; - } - - /** - * Extracts all the values from the given String (hand) - * - * @param hand - * @return The values of all the cards - */ - private char[] getValues(String hand) { - char[] values = "".toCharArray(); - String temp = ""; - - // Find all values - for (int i = 1; i < hand.length(); i += 2) { - temp += hand.charAt(i); - } - values = temp.toCharArray(); - Arrays.sort(values); - return values; - } - - /** - * Extracts all the colors from the given String (hand) - * - * @param hand - * @return The colors of all the cards - */ - private char[] getColors(String hand) { - char[] colors = "".toCharArray(); - String temp = ""; - - // Find all values - for (int i = 0; i < hand.length() - 1; i += 2) { - temp += hand.charAt(i); - } - colors = temp.toCharArray(); - Arrays.sort(colors); - return colors; - } - - /** - * Finds a Flush by looking if all cards has the same colors - * - * @param hand - * @return true if there is a flush, otherwise false - */ - private boolean findFlush(String hand) { - char[] colors = getColors(hand); - - // Loop again, find pair - if (colors[0] == colors[1] && colors[1] == colors[2] && colors[2] == colors[3] && colors[3] == colors[4]) - return true; - return false; - } } 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 28b420e..3d3e297 100644 --- a/PokerKata/test/session3/PokerGameTest.java +++ b/PokerKata/test/session3/PokerGameTest.java @@ -1,81 +1,42 @@ -/** - * 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 { - PokerGame myGame = new PokerGame(); @Test - public void nothing_gives_0() throws Exception { - String hand = "S2K3R5H6S7"; + 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(); - int result = myGame.getScore(hand); + Player winningPlayer = game.calculateWinningPlayer(green, white); - assertEquals(0, result); + assertEquals("Green", winningPlayer.getPlayerName()); } @Test - public void single_pair_gives_2() throws Exception { - String hand = "S2K2R5H6S7"; + 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(); - int result = myGame.getScore(hand); - - assertEquals(2, result); + Player winningPlayer = game.calculateWinningPlayer(green, white); + + assertEquals("White", winningPlayer.getPlayerName()); } - + @Test - public void three_of_a_kind_gives_3() throws Exception { - String hand = "S2K2R2H6S7"; + 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(); - int result = myGame.getScore(hand); - - assertEquals(3, result); - } - - @Test - public void two_pairs_gives_6() throws Exception { - String hand = "S2K2R5H7S7"; - - int result = myGame.getScore(hand); - - assertEquals(6, result); - } - - @Test - public void four_of_a_kind_gives_7() throws Exception { - String hand = "S2K2R2H2S7"; - - int result = myGame.getScore(hand); - - assertEquals(7, result); - } - - @Test - public void full_house_gives_9() throws Exception { - String hand = "S2K2R2H7S7"; - - int result = myGame.getScore(hand); - - assertEquals(9, result); - } - - @Test - public void flush_gives_10() throws Exception { - String hand = "S2S6S7S8S9"; - - int result = myGame.getScore(hand); - - assertEquals(10, result); + Player winningPlayer = game.calculateWinningPlayer(green, white); + + assertEquals("White", winningPlayer.getPlayerName()); } } diff --git a/PokerKata/test/session3/TwoPairRuleTest.java b/PokerKata/test/session3/TwoPairRuleTest.java new file mode 100644 index 0000000..2d2e2b6 --- /dev/null +++ b/PokerKata/test/session3/TwoPairRuleTest.java @@ -0,0 +1,40 @@ +package session3; + +import static org.junit.Assert.*; + +import org.junit.Test; + +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()); + } +}