Change code according to FridaTveit's review

config.json~

+{
+  "slug": "java",
+  "language": "Java",
+  "repository": "https://github.com/exercism/xjava",
+  "active": true,
+  "exercises": [
+    {
+      "slug": "hello-world",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "rna-transcription",
+      "difficulty": 2,
+      "topics": []
+    },
+    {
+      "slug": "pangram",
+      "difficulty": 3,
+      "topics": []
+    },
+    {
+      "slug": "hamming",
+      "difficulty": 3,
+      "topics": []
+    },
+    {
+      "slug": "gigasecond",
+      "difficulty": 3,
+      "topics": []
+    },
+    {
+      "slug": "space-age",
+      "difficulty": 3,
+      "topics": []
+    },
+    {
+      "slug": "acronym",
+      "difficulty": 3,
+      "topics": []
+    },
+    {
+      "slug": "scrabble-score",
+      "difficulty": 3,
+      "topics": []
+    },
+    {
+      "slug": "raindrops",
+      "difficulty": 3,
+      "topics": []
+    },
+    {
+      "slug": "difference-of-squares",
+      "difficulty": 3,
+      "topics": []
+    },
+    {
+      "slug": "secret-handshake",
+      "difficulty": 3,
+      "topics": []
+    },
+    {
+      "slug": "sum-of-multiples",
+      "difficulty": 4,
+      "topics": []
+    },
+    {
+      "slug": "luhn",
+      "difficulty": 4,
+      "topics": []
+    },
+    {
+      "slug": "matrix",
+      "difficulty": 4,
+      "topics": []
+    },
+    {
+      "slug": "triangle",
+      "difficulty": 4,
+      "topics": []
+    },
+    {
+      "slug": "largest-series-product",
+      "difficulty": 4,
+      "topics": []
+    },
+    {
+      "slug": "sieve",
+      "difficulty": 4,
+      "topics": []
+    },
+    {
+      "slug": "twelve-days",
+      "difficulty": 4,
+      "topics": []
+    },
+    {
+      "slug": "nth-prime",
+      "difficulty": 4,
+      "topics": []
+    },
+    {
+      "slug": "diamond",
+      "difficulty": 4,
+      "topics": []
+    },
+    {
+      "slug": "flatten-array",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "pig-latin",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "phone-number",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "accumulate",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "nucleotide-count",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "word-count",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "robot-name",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "prime-factors",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "allergies",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "bob",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "pascals-triangle",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "bracket-push",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "series",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "atbash-cipher",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "strain",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "roman-numerals",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "beer-song",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "queen-attack",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "etl",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "linked-list",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "grade-school",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "robot-simulator",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "binary-search",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "minesweeper",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "wordy",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "all-your-base",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "anagram",
+      "difficulty": 7,
+      "topics": []
+    },
+    {
+      "slug": "sublist",
+      "difficulty": 7,
+      "topics": []
+    },
+    {
+      "slug": "simple-linked-list",
+      "difficulty": 7,
+      "topics": []
+    },
+    {
+      "slug": "binary-search-tree",
+      "difficulty": 7,
+      "topics": []
+    },
+    {
+      "slug": "rectangles",
+      "difficulty": 7,
+      "topics": []
+    },
+    {
+      "slug": "meetup",
+      "difficulty": 7,
+      "topics": []
+    },
+    {
+      "slug": "crypto-square",
+      "difficulty": 7,
+      "topics": []
+    },
+    {
+      "slug": "poker",
+      "difficulty": 7,
+      "topics": [
+        "Parsing",
+        "Sorting",
+        "Games"
+      ]
+    },
+    {
+      "slug": "simple-cipher",
+      "difficulty": 8,
+      "topics": []
+    },
+    {
+      "slug": "palindrome-products",
+      "difficulty": 8,
+      "topics": []
+    },
+    {
+      "slug": "pythagorean-triplet",
+      "difficulty": 9,
+      "topics": []
+    },
+    {
+      "slug": "custom-set",
+      "difficulty": 10,
+      "topics": []
+    },
+    {
+      "slug": "clock",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "perfect-numbers",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "change",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "list-ops",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "ocr-numbers",
+      "difficulty": 1,
+      "topics": []
+    }
+  ],
+  "deprecated": [
+    "binary",
+    "hexadecimal",
+    "octal",
+    "trinary"
+  ],
+  "ignored": [
+    "_template",
+    ".gradle",
+    "build",
+    "docs",
+    "gradle",
+    "scripts"
+  ],
+  "foregone": [
+    "leap",
+    "grains",
+    "say"
+  ]
+}

exercises/poker/src/example/java/Poker.java

 public class Poker {
 	private static class Card {
 		private int rank;
-		private int Suit;
+		private int suit;
 
 		public Card(String card) {
-			rank = Parserank(card);
-			Suit = ParseSuit(card);
+			rank = parseRank(card);
+			suit = parseSuit(card);
 		}
 
-		public int getRank() {
+		private int getRank() {
 			return rank;
 		}
-	}
-
-	private static class Hand {
-		private String input;
-		private int score;
-
-		public Hand(String hand) {
-			this.input = hand;
-			this.score = ScoreHand(ParseCards(hand));
-		}
-		
-		public int getScore() {
-			return score;
-		}
 
-		public String getInput() {
-			return input;
+		private int getSuit() {
+			return suit;
 		}
-	}
 
-	public static List<String> BestHands(List<String> hands) {
-		ArrayList<Hand> scoredHands = new ArrayList<Hand>();
-
-		for (String s : hands) {
-			scoredHands.add(new Hand(s));
+		private static int parseRank(String card) {
+			return "..23456789TJQKA".indexOf(card.charAt(0));
 		}
 
-		int maxscore = scoredHands.stream().map(h -> h.getScore()).max(Comparator.naturalOrder()).get();
-		return scoredHands.stream().filter(h -> h.getScore() == maxscore).map(h -> h.getInput())
-				.collect(Collectors.toList());
-	}
-
-	public static List<Card> ParseCards(String hand) {
-		ArrayList<Card> parseCards = new ArrayList<Card>();
-		String[] parseString = hand.split(" ");
-		for (int i = 0; i < parseString.length; i++) {
-			parseCards.add(new Poker.Card(parseString[i]));
+		private static int parseSuit(String card) {
+			return ".HSDC".indexOf(card.charAt(1));
 		}
-		return parseCards;
-	}
-
-	public static int Parserank(String card) {
-		return "..23456789TJQKA".indexOf(card.charAt(0));
-	}
-
-	public static int ParseSuit(String card) {
-		return ".HSDC".indexOf(card.charAt(1));
 	}
 
-	private static int ScoreHand(List<Card> cards) {
-
-		List<Card> cardsByrank = new ArrayList<Card>();
+		private static class Hand {
+			private String input;
+			private int score;
 
-		cardsByrank = cards.stream().sorted(Comparator.comparing(Card::getRank)).unordered()
-				.collect(Collectors.toList());
-
-		Map<Integer, Integer> frequencymap = new HashMap<Integer, Integer>();
-		for (Card c : cards) {
-			if (frequencymap.containsKey(c.rank)) {
-				frequencymap.put(c.getRank(), frequencymap.get(c.getRank()) + 1);
-			} else {
-				frequencymap.put(c.getRank(), 1);
+			private Hand(String hand) {
+				this.input = hand;
+				this.score = scoreHand(parseCards(hand));
 			}
-		}
 
-		List<Integer> ranks = frequencymap.entrySet().stream().map(x -> x.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));
+			private int getScore() {
+				return score;
+			}
 
-		List<Integer> rankCounts = frequencymap.entrySet().stream().map(x -> x.getValue()).collect(Collectors.toList());
+			private String getInput() {
+				return input;
+			}
 
-		List<Integer> suits = cards.stream().map(s -> s.Suit).collect(Collectors.toList());
+			private static List<Card> parseCards(String hand) {
+				ArrayList<Card> parseCards = new ArrayList<Card>();
+				String[] parseString = hand.split(" ");
+				for (int i = 0; i < parseString.length; i++) {
+					parseCards.add(new Poker.Card(parseString[i]));
+				}
+				return parseCards;
+			}
 
-		if (ranks.equals(Arrays.asList(14, 5, 4, 3, 2))) {
-			ranks = Arrays.asList(5, 4, 3, 2, 1);
+			private static int scoreHand(List<Card> cards) {
+
+				List<Card> cardsByrank = new ArrayList<Card>();
+
+				cardsByrank = cards.stream().sorted(Comparator.comparing(Card::getRank)).unordered()
+						.collect(Collectors.toList());
+
+				Map<Integer, Integer> frequencymap = new HashMap<Integer, Integer>();
+				for (Card c : cards) {
+					if (frequencymap.containsKey(c.rank)) {
+						frequencymap.put(c.getRank(), frequencymap.get(c.getRank()) + 1);
+					} else {
+						frequencymap.put(c.getRank(), 1);
+					}
+				}
+
+				List<Integer> ranks = frequencymap.entrySet().stream().map(x -> x.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(x -> x.getValue())
+						.collect(Collectors.toList());
+
+				List<Integer> suits = cards.stream().map(s -> s.getSuit()).collect(Collectors.toList());
+
+				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> itr = frequencymap.keySet().iterator();
+				int pairA = itr.next();
+
+				if (straight && flush) {
+					return 800 + frequencymap.keySet().iterator().next();
+				}
+				if (rankCounts.equals(Arrays.asList(4, 1))) {
+					return (700 + (cardsByrank.get(0)).getRank());
+				}
+				if (rankCounts.equals(Arrays.asList(3, 2))) {
+					return 600 + cardsByrank.get(0).getRank();
+				}
+				if (flush) {
+					return 500 + frequencymap.keySet().iterator().next();
+				}
+				if (straight) {
+					return 400 + frequencymap.keySet().iterator().next();
+				}
+				if (rankCounts.equals(Arrays.asList(3, 1, 1))) {
+					return 300 + cardsByrank.get(0).getRank();
+				}
+				if (rankCounts.equals(Arrays.asList(2, 2, 1))) {
+					return 200 + Math.max(pairA, itr.next());
+				}
+				if (rankCounts.equals(Arrays.asList(2, 1, 1, 1))) {
+					return 100 + pairA;
+				}
+				Collections.sort(ranks, (a, b) -> b.compareTo(a));
+				Collections.reverse(ranks);
+				return ranks.get(0);
+			}
 		}
+			public static List<String> bestHands(List<String> hands) {
+				ArrayList<Hand> scoredHands = new ArrayList<Hand>();
 
-		boolean flush = suits.stream().distinct().count() == 1;
-		boolean straight = ranks.stream().distinct().count() == 5 && ranks.get(0) - ranks.get(4) == 4;
-		Iterator<Integer> itr = frequencymap.keySet().iterator();
-		int pairA = itr.next();
+				for (String s : hands) {
+					scoredHands.add(new Hand(s));
+				}
 
-		if (straight && flush) {
-			return 800 + frequencymap.keySet().iterator().next();
-		}
-		if (rankCounts.equals(Arrays.asList(4, 1))) {
-			return (700 + (cardsByrank.get(0)).getRank());
-		}
-		if (rankCounts.equals(Arrays.asList(3, 2))) {
-			return 600 + cardsByrank.get(0).getRank();
-		}
-		if (flush) {
-			return 500 + frequencymap.keySet().iterator().next();
-		}
-		if (straight) {
-			return 400 + frequencymap.keySet().iterator().next();
-		}
-		if (rankCounts.equals(Arrays.asList(3, 1, 1))) {
-			return 300 + cardsByrank.get(0).getRank();
-		}
-		if (rankCounts.equals(Arrays.asList(2, 2, 1))) {
-			return 200 + Math.max(pairA, itr.next());
-		}
-		if (rankCounts.equals(Arrays.asList(2, 1, 1, 1))) {
-			return 100 + pairA;
-		}
-		Collections.sort(ranks, (a, b) -> b.compareTo(a));
-		Collections.reverse(ranks);
-		return ranks.get(0);
-	}
-}
+				int maxscore = scoredHands.stream().map(h -> h.getScore()).max(Comparator.naturalOrder()).get();
+				return scoredHands.stream().filter(h -> h.getScore() == maxscore).map(h -> h.getInput())
+						.collect(Collectors.toList());
+			}
+}

exercises/poker/src/main/java/Poker.java

 
 public class Poker {
 
-	public static List<String> BestHands(List<String> hands) {
+	public static List<String> bestHands(List<String> hands) {
 		{
 			throw new NotImplementedException();
 		}
 	}
-}
+}

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

-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 import java.util.Arrays;
 import org.junit.Ignore;
 import org.junit.Test;
 public class PokerTest
 {
     @Test
-    public void One_hand()
+    public void OneHand()
     {
         final String hand = "4S 5S 7H 8D JC";
-        assertEquals(Arrays.asList(hand),Poker.BestHands(Arrays.asList(hand)));
+        assertEquals(Arrays.asList(hand),Poker.bestHands(Arrays.asList(hand)));
     }
 
     @Test
     @Ignore
-    public void Nothing_vs_one_pair()
+    public void NothingVsOnePair()
     {
         final String nothing = "4S 5H 6S 8D JH";
         final String pairOf4 = "2S 4H 6S 4D JH";
-        assertEquals(Arrays.asList(pairOf4), Poker.BestHands(Arrays.asList(nothing, pairOf4)));
+        assertEquals(Arrays.asList(pairOf4), Poker.bestHands(Arrays.asList(nothing, pairOf4)));
     }
 
     @Test
     @Ignore
-    public void Two_pairs()
+    public void TwoPairs()
     {
         final String pairOf2 = "4S 2H 6S 2D JH";
         final String pairOf4 = "2S 4H 6S 4D JH";
-        assertEquals(Arrays.asList(pairOf4), Poker.BestHands(Arrays.asList(pairOf2,pairOf4)));
+        assertEquals(Arrays.asList(pairOf4), Poker.bestHands(Arrays.asList(pairOf2,pairOf4)));
     }
 
     @Test
     @Ignore
-    public void One_pair_vs_double_pair()
+    public void OnePairVsDoublePair()
     {
         final String pairOf8 = "2S 8H 6S 8D JH";
         final String doublePair = "4S 5H 4S 8D 5H";
-        assertEquals(Arrays.asList(doublePair), Poker.BestHands(Arrays.asList(pairOf8, doublePair)));
+        assertEquals(Arrays.asList(doublePair), Poker.bestHands(Arrays.asList(pairOf8, doublePair)));
     }
 
     @Test
     @Ignore
-    public void Two_double_pairs()
+    public void TwoDoublePairs()
     {
         final String doublePair2And8 = "2S 8H 2S 8D JH";
         final String doublePair4And5 = "4S 5H 4S 8D 5H";
-        assertEquals(Arrays.asList(doublePair2And8), Poker.BestHands(Arrays.asList(doublePair2And8, doublePair4And5)));
+        assertEquals(Arrays.asList(doublePair2And8), Poker.bestHands(Arrays.asList(doublePair2And8, doublePair4And5)));
     }
 
     @Test
     @Ignore
-    public void Double_pair_vs_three()
+    public void DoublePairVsThree()
     {
         final String doublePair2And8 = "2S 8H 2S 8D JH";
         final String threeOf4 = "4S 5H 4S 8D 4H";
-        assertEquals(Arrays.asList(threeOf4 ), Poker.BestHands(Arrays.asList(doublePair2And8, threeOf4 )));
+        assertEquals(Arrays.asList(threeOf4 ), Poker.bestHands(Arrays.asList(doublePair2And8, threeOf4 )));
     }
 
     @Test
     @Ignore
-    public void Two_threes()
+    public void TwoThrees()
     {
         final String threeOf2 = "2S 2H 2S 8D JH";
         final String threeOf1 = "4S AH AS 8D AH";
-        assertEquals(Arrays.asList(threeOf1), Poker.BestHands(Arrays.asList(threeOf2, threeOf1)));
+        assertEquals(Arrays.asList(threeOf1), Poker.bestHands(Arrays.asList(threeOf2, threeOf1)));
     }
 
     @Test
     @Ignore
-    public void Three_vs_straight()
+    public void ThreeVsStraight()
     {
         final String threeOf4 = "4S 5H 4S 8D 4H";
         final String straight = "3S 4H 2S 6D 5H";
-        assertEquals(Arrays.asList(straight), Poker.BestHands(Arrays.asList(threeOf4, straight )));
+        assertEquals(Arrays.asList(straight), Poker.bestHands(Arrays.asList(threeOf4, straight )));
     }
 
     @Test
     @Ignore
-    public void Two_straights()
+    public void TwoStraights()
     {
         final String straightTo8 = "4S 6H 7S 8D 5H";
         final String straightTo9 = "5S 7H 8S 9D 6H";
-        assertEquals(Arrays.asList(straightTo9 ), Poker.BestHands(Arrays.asList(straightTo8, straightTo9 )));
+        assertEquals(Arrays.asList(straightTo9 ), Poker.bestHands(Arrays.asList(straightTo8, straightTo9 )));
 
         final String straightTo1 = "AS QH KS TD JH";
         final String straightTo5 = "4S AH 3S 2D 5H";
-        assertEquals(Arrays.asList(straightTo1), Poker.BestHands(Arrays.asList(straightTo1, straightTo5)));
+        assertEquals(Arrays.asList(straightTo1), Poker.bestHands(Arrays.asList(straightTo1, straightTo5)));
     }
 
     @Test
     @Ignore
-    public void Straight_vs_flush()
+    public void StraightVsFlush()
     {
         final String straightTo8 = "4S 6H 7S 8D 5H";
         final String flushTo7 = "2S 4S 5S 6S 7S";
-        assertEquals(Arrays.asList(flushTo7 ), Poker.BestHands(Arrays.asList(straightTo8, flushTo7 )));
+        assertEquals(Arrays.asList(flushTo7 ), Poker.bestHands(Arrays.asList(straightTo8, flushTo7 )));
     }
 
     @Test
     @Ignore
-    public void Two_flushes()
+    public void TwoFlushes()
     {
         final String flushTo8 = "3H 6H 7H 8H 5H";
         final String flushTo7 = "2S 4S 5S 6S 7S";
-        assertEquals(Arrays.asList(flushTo8), Poker.BestHands(Arrays.asList(flushTo8, flushTo7)));
+        assertEquals(Arrays.asList(flushTo8), Poker.bestHands(Arrays.asList(flushTo8, flushTo7)));
     }
 
     @Test
     @Ignore
-    public void Flush_vs_full()
+    public void FlushVsFull()
     {
         final String flushTo8 = "3H 6H 7H 8H 5H";
         final String full = "4S 5H 4S 5D 4H";
-        assertEquals(Arrays.asList(full ), Poker.BestHands(Arrays.asList(full, flushTo8)));
+        assertEquals(Arrays.asList(full ), Poker.bestHands(Arrays.asList(full, flushTo8)));
     }
 
     @Test
     @Ignore
-    public void Two_fulls()
+    public void TwoFulls()
     {
         final String fullOf4By9 = "4H 4S 4D 9S 9D";
         final String fullOf5By8 = "5H 5S 5D 8S 8D";
-        assertEquals(Arrays.asList(fullOf5By8 ), Poker.BestHands(Arrays.asList(fullOf4By9, fullOf5By8)));
+        assertEquals(Arrays.asList(fullOf5By8 ), Poker.bestHands(Arrays.asList(fullOf4By9, fullOf5By8)));
     }
 
     @Test
     @Ignore
-    public void Full_vs_square()
+    public void FullVsSquare()
     {
         final String full = "4S 5H 4S 5D 4H";
         final String squareOf3 = "3S 3H 2S 3D 3H";
-        assertEquals(Arrays.asList(squareOf3 ), Poker.BestHands(Arrays.asList(full, squareOf3 )));
+        assertEquals(Arrays.asList(squareOf3 ), Poker.bestHands(Arrays.asList(full, squareOf3 )));
     }
 
     @Test
     @Ignore
-    public void Two_squares()
+    public void TwoSquares()
     {
         final String squareOf2 = "2S 2H 2S 8D 2H";
         final String squareOf5 = "4S 5H 5S 5D 5H";
-        assertEquals(Arrays.asList(squareOf5), Poker.BestHands(Arrays.asList(squareOf2, squareOf5)));
+        assertEquals(Arrays.asList(squareOf5), Poker.bestHands(Arrays.asList(squareOf2, squareOf5)));
     }
 
     @Test
     @Ignore
-    public void Square_vs_straight_flush()
+    public void SquareVsStraightFlush()
     {
         final String squareOf5 = "4S 5H 5S 5D 5H";
         final String straightFlushTo9 = "5S 7S 8S 9S 6S";
-        assertEquals(Arrays.asList(straightFlushTo9 ), Poker.BestHands(Arrays.asList(squareOf5, straightFlushTo9 )));
+        assertEquals(Arrays.asList(straightFlushTo9 ), Poker.bestHands(Arrays.asList(squareOf5, straightFlushTo9 )));
     }
 
     @Test
     @Ignore
-    public void Two_straight_flushes()
+    public void TwoStraightFlushes()
     {
         final String straightFlushTo8 = "4H 6H 7H 8H 5H";
         final String straightFlushTo9 = "5S 7S 8S 9S 6S";
-        assertEquals(Arrays.asList(straightFlushTo9 ), Poker.BestHands(Arrays.asList(straightFlushTo8, straightFlushTo9)));
+        assertEquals(Arrays.asList(straightFlushTo9 ), Poker.bestHands(Arrays.asList(straightFlushTo8, straightFlushTo9)));
     }
 
     @Test
     @Ignore
-    public void Three_hand_with_tie()
+    public void ThreeHandWithTie()
     {
         final String spadeStraightTo9 = "9S 8S 7S 6S 5S";
         final String diamondStraightTo9 = "9D 8D 7D 6D 5D";
         final String threeOf4 = "4D 4S 4H QS KS";
-        assertEquals(Arrays.asList(spadeStraightTo9, diamondStraightTo9), Poker.BestHands(Arrays.asList(spadeStraightTo9, diamondStraightTo9, threeOf4)));
+        assertEquals(Arrays.asList(spadeStraightTo9, diamondStraightTo9), Poker.bestHands(Arrays.asList(spadeStraightTo9, diamondStraightTo9, threeOf4)));
     }
 
     @Test
     @Ignore
-    public void Straight_to_5_against_a_pair_of_jacks()
+    public void StraightTo5AgainstAPairOfJacks()
     {
         final String straightTo5 = "2S 4D 5C 3S AS";
         final String twoJacks = "JD 8D 7D JC 5D";
-        assertEquals(Arrays.asList(straightTo5), Poker.BestHands(Arrays.asList(straightTo5, twoJacks)));
+        assertEquals(Arrays.asList(straightTo5), Poker.bestHands(Arrays.asList(straightTo5, twoJacks)));
     }
 }