Merge from home

PokerGame.java
PokerGameTest.java

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;
+	}
+	
+}

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<Card> playerHand1 = player1.getPlayerHand();
+		List<Card> 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;
+	}
+
+}

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;
+	}
+
+}

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<Card> cards;
+
+	public Player(String name, String cards) {
+		this.name = name;
+		this.cards = new ArrayList<Card>();
+		String[] split = cards.split(" ");
+		for (String val : split) {
+			this.cards.add(new Card(val));
+		}
+	}
+
+	public String getPlayerName() {
+		return name;
+	}
+
+	public List<Card> getPlayerHand() {
+		return this.cards;
+	}
+
+}

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);
 	}
 
 }

PokerKata/src/session3/PokerGameComparator.java

@@ -0,0 +1,12 @@
+package session3;
+
+import java.util.Comparator;
+
+public class PokerGameComparator implements Comparator<Card> {
+
+	@Override
+	public int compare(Card arg0, Card arg1) {
+		return arg1.getValue() - arg0.getValue();
+	}
+
+}

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;
+	}
+
+}

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());
+	}
+	
+}

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());
+	}
+
+}

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);
+	}
+
+}

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<Card> listCard = new ArrayList<Card>();
+		listCard.add(new Card("5H"));
+		Player player = new Player("bob", "5H");
+
+		List<Card> result = player.getPlayerHand();
+
+		assertEquals(listCard.get(0).getValue(), result.get(0).getValue());
+	}
+
+	@Test
+	public void constructor_handles_multiple_cards() throws Exception {
+		List<Card> listCard = new ArrayList<Card>();
+		listCard.add(new Card("5H"));
+		listCard.add(new Card("3H"));
+		Player player = new Player("bob", "5H 3H");
+
+		List<Card> result = player.getPlayerHand();
+
+		assertEquals(listCard.size(), result.size());
+	}
+	
+	@Test
+	public void constructor_handles_multiple_cards_suit_cards() throws Exception {
+		List<Card> listCard = new ArrayList<Card>();
+		listCard.add(new Card("5H"));
+		listCard.add(new Card("3H"));
+		Player player = new Player("bob", "5H 3H");
+
+		List<Card> result = player.getPlayerHand();
+
+		assertEquals(listCard.size(), result.size());
+	}	
+}

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<Card> 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());
+
+	}
+
+}

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
 	}
 }

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());
+	}
+}

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