Change indentation and correct mistakes

exercises/poker/.meta/src/reference/java/Card.java

@@ -17,13 +17,12 @@ class Card {
 
     private int parseRank(String card) {
     	if (card.substring(0, 2).equals("10")) {
-			return 10;
-		}
-		String s = "..23456789TJQKA";
-		return s.indexOf(card.charAt(0));
+    		return 10;
+    	}
+    	return "..23456789TJQKA".indexOf(card.charAt(0));
     }
 
     private int parseSuit(String card) {
-        return ".HSDC".indexOf(card.charAt(card.length()-1));
+        return ".HSDC".indexOf(card.charAt(card.length() - 1));
     }
 }

exercises/poker/.meta/src/reference/java/Hand.java

@@ -2,129 +2,152 @@ import java.util.*;
 import java.util.stream.Collectors;
 
 class Hand {
-	private String input;
-	private int score;
+    private String input;
+    private int score;
 
-	Hand(String hand) {
-		this.input = hand;
-		this.score = scoreHand(parseCards(hand));
-	}
+    Hand(String hand) {
+        this.input = hand;
+        this.score = scoreHand(parseCards(hand));
+    }
 
-	int getScore() {
-		return score;
-	}
+    int getScore() {
+        return score;
+    }
 
-	String getInput() {
-		return input;
-	}
+    String getInput() {
+        return input;
+    }
 
-	private List<Card> parseCards(String hand) {
-		ArrayList<Card> parsedCards = new ArrayList<>();
-		String[] cardsToParse = hand.split(" ");
-		for (String cardToParse : cardsToParse) {
-			parsedCards.add(new Card(cardToParse));
-		}
-		return parsedCards;
-	}
+    private List<Card> parseCards(String hand) {
+        ArrayList<Card> parsedCards = new ArrayList<>();
+        String[] cardsToParse = hand.split(" ");
+        for (String cardToParse : cardsToParse) {
+            parsedCards.add(new Card(cardToParse));
+        }
+        return parsedCards;
+    }
 
-	private Map<Integer, Integer> getFrequencyMap(List<Card> cards) {
-		Map<Integer, Integer> frequencyMap = new HashMap<>();
-		for (Card c : cards) {
-			if (frequencyMap.containsKey(c.getRank())) {
-				frequencyMap.put(c.getRank(), frequencyMap.get(c.getRank()) + 1);
-			} else {
-				frequencyMap.put(c.getRank(), 1);
-			}
-		}
-		return frequencyMap;
-	}
+    private Map<Integer, Integer> getFrequencyMap(List<Card> cards) {
+        Map<Integer, Integer> frequencyMap = new HashMap<>();
+        for (Card c : cards) {
+            if (frequencyMap.containsKey(c.getRank())) {
+                frequencyMap.put(c.getRank(), frequencyMap.get(c.getRank()) + 1);
+            } else {
+                    frequencyMap.put(c.getRank(), 1);
+            }
+        }
+        return frequencyMap;
+    }
+    
+    private int scoreHand(List<Card> cards) {
+        List<Card> cardsByRank = cards.stream()
+                .sorted(Comparator.comparing(Card::getRank))
+                .unordered()
+                .collect(Collectors.toList());
 
-	private int scoreHand(List<Card> cards) {
-		List<Card> cardsByRank = cards.stream().sorted(Comparator.comparing(Card::getRank)).unordered()
-				.collect(Collectors.toList());
+        Map<Integer, Integer> frequencyMap = getFrequencyMap(cards);
+        List<Integer> ranks = frequencyMap
+                .entrySet()
+                .stream()
+                .map(Map.Entry::getKey)
+                .sorted(Comparator.reverseOrder())
+                .collect(Collectors.toList());
+        frequencyMap = frequencyMap
+                .entrySet()
+                .stream()
+                .sorted(Map.Entry.comparingByValue(Collections.reverseOrder()))
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
+        List<Integer> rankCounts = frequencyMap
+                .entrySet()
+                .stream()
+                .map(Map.Entry::getValue)
+                .collect(Collectors.toList());
+        List<Integer> suits = cards
+                .stream()
+                .map(Card::getSuit)
+                .collect(Collectors.toList());
 
-		Map<Integer, Integer> frequencyMap = getFrequencyMap(cards);
-		List<Integer> ranks = frequencyMap.entrySet().stream().map(Map.Entry::getKey).sorted(Comparator.reverseOrder())
-				.collect(Collectors.toList());
-		frequencyMap = frequencyMap.entrySet().stream().sorted(Map.Entry.comparingByValue(Collections.reverseOrder()))
-				.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
-		List<Integer> rankCounts = frequencyMap.entrySet().stream().map(Map.Entry::getValue)
-				.collect(Collectors.toList());
-		List<Integer> suits = cards.stream().map(Card::getSuit).collect(Collectors.toList());
+        return calculatedScore(frequencyMap, cardsByRank, ranks, rankCounts, suits);
+    }
 
-		return calculatedScore(frequencyMap, cardsByRank, ranks, rankCounts, suits);
-	}
+    private int calculatedScore(Map<Integer, Integer> frequencyMap, List<Card> cardsByRank, List<Integer> ranks,
+                                List<Integer> rankCounts, List<Integer> suits) {
+        if (ranks.equals(Arrays.asList(14, 5, 4, 3, 2))) {
+            ranks = Arrays.asList(5, 4, 3, 2, 1);
+        }
 
-	private int calculatedScore(Map<Integer, Integer> frequencyMap, List<Card> cardsByRank, List<Integer> ranks,
-			List<Integer> rankCounts, List<Integer> suits) {
-		if (ranks.equals(Arrays.asList(14, 5, 4, 3, 2))) {
-			ranks = Arrays.asList(5, 4, 3, 2, 1);
-		}
+        boolean flush = suits
+                .stream()
+                .distinct()
+                .count() == 1;
+        boolean straight = ranks
+                .stream()
+                .distinct()
+                .count() == 5 && ranks
+                .get(0) - ranks
+                .get(4) == 4;
+        
+        Iterator<Integer> iteratorOverFrequencies = frequencyMap.keySet().iterator();
+        
+        int highestFrequency = iteratorOverFrequencies.next();
 
-		boolean flush = suits.stream().distinct().count() == 1;
-		boolean straight = ranks.stream().distinct().count() == 5 && ranks.get(0) - ranks.get(4) == 4;
-		Iterator<Integer> iteratorOverFrequencies = frequencyMap.keySet().iterator();
-		int highestFrequency = iteratorOverFrequencies.next();
+        int maxValue = Collections.max(ranks);
 
-		int maxValue = Collections.max(ranks);
-
-		if (straight && flush) {
-			return 800 + highestFrequency;
-		}
-		if (rankCounts.equals(Arrays.asList(4, 1))) {
-			return 700 + cardsByRank.get(0).getRank();
-		}
-		if (rankCounts.equals(Arrays.asList(3, 2))) {
-			int triplet = 0;
-			int pair = 0;
-			for (Object key : frequencyMap.keySet()) {
-				if (frequencyMap.get(key) == 2) {
-					pair = (int) key;
-				}
-				if (frequencyMap.get(key) == 3) {
-					triplet = 3 * (int) key;
-				}
-			}
-			return 600 + 3 * triplet + pair;
-		}
-		if (flush) {
-			return 500 + highestFrequency;
-		}
-		if (straight) {
-			return 400 + maxValue;
-		}
-		if (rankCounts.equals(Arrays.asList(3, 1, 1))) {
-			List<Integer> cardsf1 = new ArrayList<Integer>();
-			int triplet = 0;
-			for (Object key : frequencyMap.keySet()) {
-				if (frequencyMap.get(key) == 1) {
-					cardsf1.add((int) key);
-				}
-				if (frequencyMap.get(key) == 3) {
-					triplet = 3 * (int) key;
-				}
-			}
-
-			return 300 + triplet + Collections.max(cardsf1);
-		}
-		if (rankCounts.equals(Arrays.asList(2, 2, 1))) {
-			int sum = 0;
-			for (Object key : frequencyMap.keySet()) {
-				int fKey = (int) key;
-				int fValue = frequencyMap.get(key);
-				sum += fKey * fValue;
-			}
-			return 200 + sum + 2 * Math.max(highestFrequency, iteratorOverFrequencies.next());
-		}
-		if (rankCounts.equals(Arrays.asList(2, 1, 1, 1))) {
-			return 100 + highestFrequency;
-		}
-		ranks.sort(Comparator.naturalOrder());
-		int result = 0;
-		for (int i = 0; i < ranks.size(); i++) {
-			result += ranks.get(0) * (i + 1);
-		}
-		return result + ranks.get(ranks.size() - 1);
-	}
-
-}
+        if (straight && flush) {
+            return 800 + highestFrequency;
+        }
+        if (rankCounts.equals(Arrays.asList(4, 1))) {
+            return 700 + cardsByRank.get(0).getRank();
+        }
+        if (rankCounts.equals(Arrays.asList(3, 2))) {
+            int triplet = 0;
+            int pair = 0;
+            for (Integer key : frequencyMap.keySet()) {
+                if (frequencyMap.get(key) == 2) {
+                    pair = (int) key;
+                }
+                if (frequencyMap.get(key) == 3) {
+                    triplet = 3 * (int) key;
+                }
+            }
+            return 600 + 3 * triplet + pair;
+        }
+        if (flush) {
+            return 500 + highestFrequency;
+        }
+        if (straight) {
+            return 400 + maxValue;
+        }
+        if (rankCounts.equals(Arrays.asList(3, 1, 1))) {
+            List<Integer> unique_cards = new ArrayList<Integer>();
+            int triplet = 0;
+            for (Integer key : frequencyMap.keySet()) {
+                if (frequencyMap.get(key) == 1) {
+                    unique_cards.add((int) key);
+                }
+                if (frequencyMap.get(key) == 3) {
+                    triplet = 3 * (int) key;
+                }
+            }
+            return 300 + triplet + Collections.max(unique_cards);
+        }
+        if (rankCounts.equals(Arrays.asList(2, 2, 1))) {
+            int products_of_frequency_and_value = 0;
+            for (Integer key : frequencyMap.keySet()) {
+                int frequencyKey = (int) key;
+                int frequencyValue = frequencyMap.get(key);
+                products_of_frequency_and_value += frequencyKey * frequencyValue;
+            }
+            return 200 + products_of_frequency_and_value + 2 * Math.max(highestFrequency, iteratorOverFrequencies.next());
+        }
+        if (rankCounts.equals(Arrays.asList(2, 1, 1, 1))) {
+            return 100 + highestFrequency;
+        }
+        ranks.sort(Comparator.naturalOrder());
+        int result = 0;
+        for (int i = 0; i < ranks.size(); i++) {
+            result += ranks.get(0) * (i + 1);
+        }
+        return result + ranks.get(ranks.size() - 1);
+    }
+}               

exercises/poker/src/test/java/PokerTest.java

@@ -1,239 +1,232 @@
-import org.junit.Ignore;
-import org.junit.Test;
-
-import java.util.Arrays;
-
-import static org.junit.Assert.assertEquals;
-
 public class PokerTest {
-	@Test
-	public void oneHand() {
-		String hand = "4S 5S 7H 8D JC";
-		assertEquals(Arrays.asList(hand), new Poker(Arrays.asList(hand)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void highestCardWins() {
-		String highest8 = "4D 5S 6S 8D 3C";
-		String highest10 = "2S 4C 7S 9H 10H";
-		String highestJ = "3S 4S 5D 6H JH";
-		assertEquals(Arrays.asList(highestJ), new Poker(Arrays.asList(highest8, highest10, highestJ)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void tieHasMultipleWinners() {
-		String highest8 = "4D 5S 6S 8D 3C";
-		String highest10 = "2S 4C 7S 9H 10H";
-		String highestJh = "3S 4S 5D 6H JH";
-		String highestJd = "3H 4H 5C 6C JD";
-		assertEquals(Arrays.asList(highestJh, highestJd),
-				new Poker(Arrays.asList(highest8, highest10, highestJh, highestJd)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void sameHighCards() {
-		String nextHighest3 = "3S 5H 6S 8D 7H";
-		String nextHighest2 = "2S 5D 6D 8C 7S";
-		assertEquals(Arrays.asList(nextHighest3), new Poker(Arrays.asList(nextHighest3, nextHighest2)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void nothingVsOnePair() {
-		String nothing = "4S 5H 6C 8D KH";
-		String pairOf4 = "2S 4H 6S 4D JH";
-		assertEquals(Arrays.asList(pairOf4), new Poker(Arrays.asList(nothing, pairOf4)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void twoPairs() {
-		String pairOf2 = "4S 2H 6S 2D JH";
-		String pairOf4 = "2S 4H 6C 4D JD";
-		assertEquals(Arrays.asList(pairOf4), new Poker(Arrays.asList(pairOf2, pairOf4)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void onePairVsDoublePair() {
-		String pairOf8 = "2S 8H 6S 8D JH";
-		String doublePair = "4S 5H 4C 8C 5H";
-		assertEquals(Arrays.asList(doublePair), new Poker(Arrays.asList(pairOf8, doublePair)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void twoDoublePairs() {
-		String doublePair2And8 = "2S 8H 2D 8D 3H";
-		String doublePair4And5 = "4S 5H 4C 8S 5D";
-		assertEquals(Arrays.asList(doublePair2And8),
-				new Poker(Arrays.asList(doublePair2And8, doublePair4And5)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void sameHighestPair() {
-		String doublePair2AndQ = "2S QS 2C QD JH";
-		String doublePairJAndQ = "JD QH JS 8D QC";
-		assertEquals(Arrays.asList(doublePairJAndQ),
-				new Poker(Arrays.asList(doublePairJAndQ, doublePair2AndQ)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void identicallyRankedPairs() {
-		String kicker8 = "JD QH JS 8D QC";
-		String kicker2 = "JS QS JC 2D QD";
-		assertEquals(Arrays.asList(kicker8), new Poker(Arrays.asList(kicker8, kicker2)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void doublePairVsThree() {
-		String doublePair2And8 = "2S 8H 2H 8D JH";
-		String threeOf4 = "4S 5H 4C 8S 4H";
-		assertEquals(Arrays.asList(threeOf4), new Poker(Arrays.asList(doublePair2And8, threeOf4)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void twoThrees() {
-		String threeOf2 = "2S 2H 2C 8D JH";
-		String threeOf1 = "4S AH AS 8C AD";
-		assertEquals(Arrays.asList(threeOf1), new Poker(Arrays.asList(threeOf2, threeOf1)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void sameThreesMultipleDecks() {
-		String remainingCard7 = "4S AH AS 7C AD";
-		String remainingCard8 = "4S AH AS 8C AD";
-		assertEquals(Arrays.asList(remainingCard8),
-				new Poker(Arrays.asList(remainingCard7, remainingCard8)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void threeVsStraight() {
-		String threeOf4 = "4S 5H 4C 8D 4H";
-		String straight = "3S 4D 2S 6D 5C";
-		assertEquals(Arrays.asList(straight), new Poker(Arrays.asList(threeOf4, straight)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void AcesCanEndAStraight() {
-		String hand = "4S 5H 4C 8D 4H";
-		String straightEndsA = "10D JH QS KD AC";
-		assertEquals(Arrays.asList(straightEndsA), new Poker(Arrays.asList(hand, straightEndsA)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void AcesCanStartAStraight() {
-		String hand = "4S 5H 4C 8D 4H";
-		String straightStartA = "4D AH 3S 2D 5C";
-		assertEquals(Arrays.asList(straightStartA), new Poker(Arrays.asList(hand, straightStartA)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void twoStraights() {
-		String straightTo8 = "4S 6C 7S 8D 5H";
-		String straightTo9 = "5S 7H 8S 9D 6H";
-		assertEquals(Arrays.asList(straightTo9), new Poker(Arrays.asList(straightTo8, straightTo9)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void theLowestStraightStartsWithAce() {
-		String straight = "2H 3C 4D 5D 6H";
-		String straightStartA = "4S AH 3S 2D 5H";
-		assertEquals(Arrays.asList(straight), new Poker(Arrays.asList(straight, straightStartA)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void straightVsFlush() {
-		String straightTo8 = "4C 6H 7D 8D 5H";
-		String flushTo7 = "2S 4S 5S 6S 7S";
-		assertEquals(Arrays.asList(flushTo7), new Poker(Arrays.asList(straightTo8, flushTo7)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void twoFlushes() {
-		String flushTo8 = "4H 7H 8H 9H 6H";
-		String flushTo7 = "2S 4S 5S 6S 7S";
-		assertEquals(Arrays.asList(flushTo8), new Poker(Arrays.asList(flushTo8, flushTo7)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void flushVsFull() {
-		String flushTo8 = "3H 6H 7H 8H 5H";
-		String full = "4S 5H 4C 5D 4H";
-		assertEquals(Arrays.asList(full), new Poker(Arrays.asList(full, flushTo8)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void twoFulls() {
-		String fullOf4By9 = "4H 4S 4D 9S 9D";
-		String fullOf5By8 = "5H 5S 5D 8S 8D";
-		assertEquals(Arrays.asList(fullOf5By8), new Poker(Arrays.asList(fullOf4By9, fullOf5By8)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void twoFullssameThripletMultipleDecks() {
-		String fullOf5By9 = "5H 5S 5D 9S 9D";
-		String fullOf5By8 = "5H 5S 5D 8S 8D";
-		assertEquals(Arrays.asList(fullOf5By9), new Poker(Arrays.asList(fullOf5By9, fullOf5By8)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void fullVsSquare() {
-		String full = "4S 5H 4D 5D 4H";
-		String squareOf3 = "3S 3H 2S 3D 3C";
-		assertEquals(Arrays.asList(squareOf3), new Poker(Arrays.asList(full, squareOf3)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void twoSquares() {
-		String squareOf2 = "2S 2H 2C 8D 2H";
-		String squareOf5 = "4S 5H 5S 5D 5C";
-		assertEquals(Arrays.asList(squareOf5), new Poker(Arrays.asList(squareOf2, squareOf5)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void sameSquaresMultipleDecks() {
-		String kicker2 = "3S 3H 2S 3D 3C";
-		String kicker4 = "3S 3H 4S 3D 3C";
-		assertEquals(Arrays.asList(kicker4), new Poker(Arrays.asList(kicker2, kicker4)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void squareVsStraightFlush() {
-		String squareOf5 = "4S 5H 5S 5D 5C";
-		String straightFlushTo9 = "7S 8S 9S 6S 10S";
-		assertEquals(Arrays.asList(straightFlushTo9),
-				new Poker(Arrays.asList(squareOf5, straightFlushTo9)).getBestHands());
-	}
-
-	@Ignore("Remove to run test")
-	@Test
-	public void twoStraightFlushes() {
-		String straightFlushTo8 = "4H 6H 7H 8H 5H";
-		String straightFlushTo9 = "5S 7S 8S 9S 6S";
-		assertEquals(Arrays.asList(straightFlushTo9),
-				new Poker(Arrays.asList(straightFlushTo8, straightFlushTo9)).getBestHands());
-	}
+    @Test
+    public void oneHand() {
+        String hand = "4S 5S 7H 8D JC";
+        assertEquals(Arrays.asList(hand), new Poker(Arrays.asList(hand)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void highestCardWins() {
+        String highest8 = "4D 5S 6S 8D 3C";
+        String highest10 = "2S 4C 7S 9H 10H";
+        String highestJ = "3S 4S 5D 6H JH";
+        assertEquals(Arrays.asList(highestJ), new Poker(Arrays.asList(highest8, highest10, highestJ)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void tieHasMultipleWinners() {
+        String highest8 = "4D 5S 6S 8D 3C";
+        String highest10 = "2S 4C 7S 9H 10H";
+        String highestJh = "3S 4S 5D 6H JH";
+        String highestJd = "3H 4H 5C 6C JD";
+        assertEquals(Arrays.asList(highestJh, highestJd),
+                new Poker(Arrays.asList(highest8, highest10, highestJh, highestJd)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void sameHighCards() {
+        String nextHighest3 = "3S 5H 6S 8D 7H";
+        String nextHighest2 = "2S 5D 6D 8C 7S";
+        assertEquals(Arrays.asList(nextHighest3), new Poker(Arrays.asList(nextHighest3, nextHighest2)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void nothingVsOnePair() {
+        String nothing = "4S 5H 6C 8D KH";
+        String pairOf4 = "2S 4H 6S 4D JH";
+        assertEquals(Arrays.asList(pairOf4), new Poker(Arrays.asList(nothing, pairOf4)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void twoPairs() {
+        String pairOf2 = "4S 2H 6S 2D JH";
+        String pairOf4 = "2S 4H 6C 4D JD";
+        assertEquals(Arrays.asList(pairOf4), new Poker(Arrays.asList(pairOf2, pairOf4)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void onePairVsDoublePair() {
+        String pairOf8 = "2S 8H 6S 8D JH";
+        String doublePair = "4S 5H 4C 8C 5C";
+        assertEquals(Arrays.asList(doublePair), new Poker(Arrays.asList(pairOf8, doublePair)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void twoDoublePairs() {
+        String doublePair2And8 = "2S 8H 2D 8D 3H";
+        String doublePair4And5 = "4S 5H 4C 8S 5D";
+        assertEquals(Arrays.asList(doublePair2And8),
+                new Poker(Arrays.asList(doublePair2And8, doublePair4And5)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void sameHighestPair() {
+        String doublePair2AndQ = "2S QS 2C QD JH";
+        String doublePairJAndQ = "JD QH JS 8D QC";
+        assertEquals(Arrays.asList(doublePairJAndQ),
+                new Poker(Arrays.asList(doublePairJAndQ, doublePair2AndQ)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void identicallyRankedPairs() {
+        String kicker8 = "JD QH JS 8D QC";
+        String kicker2 = "JS QS JC 2D QD";
+        assertEquals(Arrays.asList(kicker8), new Poker(Arrays.asList(kicker8, kicker2)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void doublePairVsThree() {
+        String doublePair2And8 = "2S 8H 2H 8D JH";
+        String threeOf4 = "4S 5H 4C 8S 4H";
+        assertEquals(Collections.singletonList(threeOf4), new Poker(Arrays.asList(doublePair2And8, threeOf4)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void twoThrees() {
+        String threeOf2 = "2S 2H 2C 8D JH";
+        String threeOf1 = "4S AH AS 8C AD";
+        assertEquals(Arrays.asList(threeOf1), new Poker(Arrays.asList(threeOf2, threeOf1)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void sameThreesMultipleDecks() {
+        String remainingCard7 = "4S AH AS 7C AD";
+        String remainingCard8 = "4S AH AS 8C AD";
+        assertEquals(Arrays.asList(remainingCard8),
+                new Poker(Arrays.asList(remainingCard7, remainingCard8)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void threeVsStraight() {
+        String threeOf4 = "4S 5H 4C 8D 4H";
+        String straight = "3S 4D 2S 6D 5C";
+        assertEquals(Arrays.asList(straight), new Poker(Arrays.asList(threeOf4, straight)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void AcesCanEndAStraight() {
+        String hand = "4S 5H 4C 8D 4H";
+        String straightEndsA = "10D JH QS KD AC";
+        assertEquals(Arrays.asList(straightEndsA), new Poker(Arrays.asList(hand, straightEndsA)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void AcesCanStartAStraight() {
+        String hand = "4S 5H 4C 8D 4H";
+        String straightStartA = "4D AH 3S 2D 5C";
+        assertEquals(Arrays.asList(straightStartA), new Poker(Arrays.asList(hand, straightStartA)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void twoStraights() {
+        String straightTo8 = "4S 6C 7S 8D 5H";
+        String straightTo9 = "5S 7H 8S 9D 6H";
+        assertEquals(Arrays.asList(straightTo9), new Poker(Arrays.asList(straightTo8, straightTo9)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void theLowestStraightStartsWithAce() {
+        String straight = "2H 3C 4D 5D 6H";
+        String straightStartA = "4S AH 3S 2D 5H";
+        assertEquals(Arrays.asList(straight), new Poker(Arrays.asList(straight, straightStartA)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void straightVsFlush() {
+        String straightTo8 = "4C 6H 7D 8D 5H";
+        String flushTo7 = "2S 4S 5S 6S 7S";
+        assertEquals(Arrays.asList(flushTo7), new Poker(Arrays.asList(straightTo8, flushTo7)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void twoFlushes() {
+        String flushTo8 = "4H 7H 8H 9H 6H";
+        String flushTo7 = "2S 4S 5S 6S 7S";
+        assertEquals(Arrays.asList(flushTo8), new Poker(Arrays.asList(flushTo8, flushTo7)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void flushVsFull() {
+        String flushTo8 = "3H 6H 7H 8H 5H";
+        String full = "4S 5H 4C 5D 4H";
+        assertEquals(Arrays.asList(full), new Poker(Arrays.asList(full, flushTo8)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void twoFulls() {
+        String fullOf4By9 = "4H 4S 4D 9S 9D";
+        String fullOf5By8 = "5H 5S 5D 8S 8D";
+        assertEquals(Arrays.asList(fullOf5By8), new Poker(Arrays.asList(fullOf4By9, fullOf5By8)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void twoFullssameThripletMultipleDecks() {
+        String fullOf5By9 = "5H 5S 5D 9S 9D";
+        String fullOf5By8 = "5H 5S 5D 8S 8D";
+        assertEquals(Arrays.asList(fullOf5By9), new Poker(Arrays.asList(fullOf5By9, fullOf5By8)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void fullVsSquare() {
+        String full = "4S 5H 4D 5D 4H";
+        String squareOf3 = "3S 3H 2S 3D 3C";
+        assertEquals(Arrays.asList(squareOf3), new Poker(Arrays.asList(full, squareOf3)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void twoSquares() {
+        String squareOf2 = "2S 2H 2C 8D 2D";
+        String squareOf5 = "4S 5H 5S 5D 5C";
+        assertEquals(Arrays.asList(squareOf5), new Poker(Arrays.asList(squareOf2, squareOf5)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void sameSquaresMultipleDecks() {
+        String kicker2 = "3S 3H 2S 3D 3C";
+        String kicker4 = "3S 3H 4S 3D 3C";
+        assertEquals(Arrays.asList(kicker4), new Poker(Arrays.asList(kicker2, kicker4)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void squareVsStraightFlush() {
+        String squareOf5 = "4S 5H 5S 5D 5C";
+        String straightFlushTo9 = "7S 8S 9S 6S 10S";
+        assertEquals(Arrays.asList(straightFlushTo9),
+                new Poker(Arrays.asList(squareOf5, straightFlushTo9)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void twoStraightFlushes() {
+        String straightFlushTo8 = "4H 6H 7H 8H 5H";
+        String straightFlushTo9 = "5S 7S 8S 9S 6S";
+        assertEquals(Arrays.asList(straightFlushTo9),
+                new Poker(Arrays.asList(straightFlushTo8, straightFlushTo9)).getBestHands());
+    }
 }