trackler 2.2.1.137 → 2.2.1.138

data/tracks/java/exercises/minesweeper/src/test/java/MinesweeperBoardTest.java

@@ -11,9 +11,9 @@ public class MinesweeperBoardTest {
 
     @Test
     public void testInputBoardWithNoRowsAndNoColumns() {
-        final List<String> inputBoard = Collections.emptyList();
-        final List<String> expectedNumberedBoard = Collections.emptyList();
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> inputBoard = Collections.emptyList();
+        List<String> expectedNumberedBoard = Collections.emptyList();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
@@ -21,9 +21,9 @@ public class MinesweeperBoardTest {
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithOneRowAndNoColumns() {
-        final List<String> inputBoard = Collections.singletonList("");
-        final List<String> expectedNumberedBoard = Collections.singletonList("");
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> inputBoard = Collections.singletonList("");
+        List<String> expectedNumberedBoard = Collections.singletonList("");
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
@@ -31,19 +31,19 @@ public class MinesweeperBoardTest {
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithNoMines() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 "   ",
                 "   ",
                 "   "
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 "   ",
                 "   ",
                 "   "
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
@@ -51,19 +51,19 @@ public class MinesweeperBoardTest {
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithOnlyMines() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 "***",
                 "***",
                 "***"
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 "***",
                 "***",
                 "***"
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
@@ -71,19 +71,19 @@ public class MinesweeperBoardTest {
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithSingleMineAtCenter() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 "   ",
                 " * ",
                 "   "
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 "111",
                 "1*1",
                 "111"
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
@@ -91,19 +91,19 @@ public class MinesweeperBoardTest {
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithMinesAroundPerimeter() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 "***",
                 "* *",
                 "***"
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 "***",
                 "*8*",
                 "***"
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
@@ -111,15 +111,15 @@ public class MinesweeperBoardTest {
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithSingleRowAndTwoMines() {
-        final List<String> inputBoard = Collections.singletonList(
+        List<String> inputBoard = Collections.singletonList(
                 " * * "
         );
 
-        final List<String> expectedNumberedBoard = Collections.singletonList(
+        List<String> expectedNumberedBoard = Collections.singletonList(
                 "1*2*1"
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
@@ -127,15 +127,15 @@ public class MinesweeperBoardTest {
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithSingleRowAndTwoMinesAtEdges() {
-        final List<String> inputBoard = Collections.singletonList(
+        List<String> inputBoard = Collections.singletonList(
                 "*   *"
         );
 
-        final List<String> expectedNumberedBoard = Collections.singletonList(
+        List<String> expectedNumberedBoard = Collections.singletonList(
                 "*1 1*"
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
@@ -143,7 +143,7 @@ public class MinesweeperBoardTest {
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithSingleColumnAndTwoMines() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 " ",
                 "*",
                 " ",
@@ -151,7 +151,7 @@ public class MinesweeperBoardTest {
                 " "
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 "1",
                 "*",
                 "2",
@@ -159,7 +159,7 @@ public class MinesweeperBoardTest {
                 "1"
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
@@ -167,7 +167,7 @@ public class MinesweeperBoardTest {
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithSingleColumnAndTwoMinesAtEdges() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 "*",
                 " ",
                 " ",
@@ -175,7 +175,7 @@ public class MinesweeperBoardTest {
                 "*"
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 "*",
                 "1",
                 " ",
@@ -183,7 +183,7 @@ public class MinesweeperBoardTest {
                 "*"
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
@@ -191,7 +191,7 @@ public class MinesweeperBoardTest {
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithMinesInCross() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 "  *  ",
                 "  *  ",
                 "*****",
@@ -199,7 +199,7 @@ public class MinesweeperBoardTest {
                 "  *  "
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 " 2*2 ",
                 "25*52",
                 "*****",
@@ -207,7 +207,7 @@ public class MinesweeperBoardTest {
                 " 2*2 "
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
@@ -215,7 +215,7 @@ public class MinesweeperBoardTest {
     @Ignore("Remove to run test")
     @Test
     public void testLargeInputBoard() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 " *  * ",
                 "  *   ",
                 "    * ",
@@ -224,7 +224,7 @@ public class MinesweeperBoardTest {
                 "      "
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 "1*22*1",
                 "12*322",
                 " 123*2",
@@ -233,7 +233,7 @@ public class MinesweeperBoardTest {
                 "111111"
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }

data/tracks/java/exercises/phone-number/src/test/java/PhoneNumberTest.java

@@ -6,12 +6,12 @@ import org.junit.rules.ExpectedException;
 import static org.junit.Assert.assertEquals;
 
 public class PhoneNumberTest {
-    private final static String wrongLengthExceptionMessage = "Number must be 10 or 11 digits";
-    private final static String numberIs11DigitsButDoesNotStartWith1ExceptionMessage =
+    private static String wrongLengthExceptionMessage = "Number must be 10 or 11 digits";
+    private static String numberIs11DigitsButDoesNotStartWith1ExceptionMessage =
             "Can only have 11 digits if number starts with '1'";
-    private final static String illegalCharacterExceptionMessage =
+    private static String illegalCharacterExceptionMessage =
             "Illegal character in phone number. Only digits, spaces, parentheses, hyphens or dots accepted.";
-    private final static String illegalAreaOrExchangeCodeMessage =
+    private static String illegalAreaOrExchangeCodeMessage =
             "Illegal Area Or Exchange Code. Only 2-9 are valid digits";
 
     @Rule
@@ -19,8 +19,8 @@ public class PhoneNumberTest {
 
     @Test
     public void cleansTheNumber() {
-        final String expectedNumber = "2234567890";
-        final String actualNumber = new PhoneNumber("(223) 456-7890").getNumber();
+        String expectedNumber = "2234567890";
+        String actualNumber = new PhoneNumber("(223) 456-7890").getNumber();
 
         assertEquals(
                 expectedNumber, actualNumber
@@ -30,8 +30,8 @@ public class PhoneNumberTest {
     @Ignore("Remove to run test")
     @Test
     public void cleansNumbersWithDots() {
-        final String expectedNumber = "2234567890";
-        final String actualNumber = new PhoneNumber("223.456.7890").getNumber();
+        String expectedNumber = "2234567890";
+        String actualNumber = new PhoneNumber("223.456.7890").getNumber();
 
         assertEquals(
                 expectedNumber, actualNumber
@@ -41,8 +41,8 @@ public class PhoneNumberTest {
     @Ignore("Remove to run test")
     @Test
     public void cleansNumbersWithMultipleSpaces() {
-        final String expectedNumber = "2234567890";
-        final String actualNumber = new PhoneNumber("223 456   7890   ").getNumber();
+        String expectedNumber = "2234567890";
+        String actualNumber = new PhoneNumber("223 456   7890   ").getNumber();
 
         assertEquals(
                 expectedNumber, actualNumber
@@ -68,8 +68,8 @@ public class PhoneNumberTest {
     @Ignore("Remove to run test")
     @Test
     public void validWhen11DigitsAndStartingWith1() {
-        final String expectedNumber = "2234567890";
-        final String actualNumber = new PhoneNumber("12234567890").getNumber();
+        String expectedNumber = "2234567890";
+        String actualNumber = new PhoneNumber("12234567890").getNumber();
 
         assertEquals(
                 expectedNumber, actualNumber
@@ -79,8 +79,8 @@ public class PhoneNumberTest {
     @Ignore("Remove to run test")
     @Test
     public void validWhen11DigitsAndStartingWith1EvenWithPunctuation() {
-        final String expectedNumber = "2234567890";
-        final String actualNumber = new PhoneNumber("+1 (223) 456-7890").getNumber();
+        String expectedNumber = "2234567890";
+        String actualNumber = new PhoneNumber("+1 (223) 456-7890").getNumber();
 
         assertEquals(
                 expectedNumber, actualNumber

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

@@ -8,156 +8,156 @@ import static org.junit.Assert.assertEquals;
 public class PokerTest {
     @Test
     public void oneHand() {
-        final String hand = "4S 5S 7H 8D JC";
+        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 nothingVsOnePair() {
-        final String nothing = "4S 5H 6S 8D JH";
-        final String pairOf4 = "2S 4H 6S 4D JH";
+        String nothing = "4S 5H 6S 8D JH";
+        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() {
-        final String pairOf2 = "4S 2H 6S 2D JH";
-        final String pairOf4 = "2S 4H 6S 4D JH";
+        String pairOf2 = "4S 2H 6S 2D JH";
+        String pairOf4 = "2S 4H 6S 4D JH";
         assertEquals(Arrays.asList(pairOf4), new Poker(Arrays.asList(pairOf2, pairOf4)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void onePairVsDoublePair() {
-        final String pairOf8 = "2S 8H 6S 8D JH";
-        final String doublePair = "4S 5H 4S 8D 5H";
+        String pairOf8 = "2S 8H 6S 8D JH";
+        String doublePair = "4S 5H 4S 8D 5H";
         assertEquals(Arrays.asList(doublePair), new Poker(Arrays.asList(pairOf8, doublePair)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void twoDoublePairs() {
-        final String doublePair2And8 = "2S 8H 2S 8D JH";
-        final String doublePair4And5 = "4S 5H 4S 8D 5H";
+        String doublePair2And8 = "2S 8H 2S 8D JH";
+        String doublePair4And5 = "4S 5H 4S 8D 5H";
         assertEquals(Arrays.asList(doublePair2And8), new Poker(Arrays.asList(doublePair2And8, doublePair4And5)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void doublePairVsThree() {
-        final String doublePair2And8 = "2S 8H 2S 8D JH";
-        final String threeOf4 = "4S 5H 4S 8D 4H";
+        String doublePair2And8 = "2S 8H 2S 8D JH";
+        String threeOf4 = "4S 5H 4S 8D 4H";
         assertEquals(Arrays.asList(threeOf4), new Poker(Arrays.asList(doublePair2And8, threeOf4)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void twoThrees() {
-        final String threeOf2 = "2S 2H 2S 8D JH";
-        final String threeOf1 = "4S AH AS 8D AH";
+        String threeOf2 = "2S 2H 2S 8D JH";
+        String threeOf1 = "4S AH AS 8D AH";
         assertEquals(Arrays.asList(threeOf1), new Poker(Arrays.asList(threeOf2, threeOf1)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void threeVsStraight() {
-        final String threeOf4 = "4S 5H 4S 8D 4H";
-        final String straight = "3S 4H 2S 6D 5H";
+        String threeOf4 = "4S 5H 4S 8D 4H";
+        String straight = "3S 4H 2S 6D 5H";
         assertEquals(Arrays.asList(straight), new Poker(Arrays.asList(threeOf4, straight)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void twoStraights() {
-        final String straightTo8 = "4S 6H 7S 8D 5H";
-        final String straightTo9 = "5S 7H 8S 9D 6H";
+        String straightTo8 = "4S 6H 7S 8D 5H";
+        String straightTo9 = "5S 7H 8S 9D 6H";
         assertEquals(Arrays.asList(straightTo9), new Poker(Arrays.asList(straightTo8, straightTo9)).getBestHands());
 
-        final String straightTo1 = "AS QH KS TD JH";
-        final String straightTo5 = "4S AH 3S 2D 5H";
+        String straightTo1 = "AS QH KS TD JH";
+        String straightTo5 = "4S AH 3S 2D 5H";
         assertEquals(Arrays.asList(straightTo1), new Poker(Arrays.asList(straightTo1, straightTo5)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void straightVsFlush() {
-        final String straightTo8 = "4S 6H 7S 8D 5H";
-        final String flushTo7 = "2S 4S 5S 6S 7S";
+        String straightTo8 = "4S 6H 7S 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() {
-        final String flushTo8 = "3H 6H 7H 8H 5H";
-        final String flushTo7 = "2S 4S 5S 6S 7S";
+        String flushTo8 = "3H 6H 7H 8H 5H";
+        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() {
-        final String flushTo8 = "3H 6H 7H 8H 5H";
-        final String full = "4S 5H 4S 5D 4H";
+        String flushTo8 = "3H 6H 7H 8H 5H";
+        String full = "4S 5H 4S 5D 4H";
         assertEquals(Arrays.asList(full), new Poker(Arrays.asList(full, flushTo8)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void twoFulls() {
-        final String fullOf4By9 = "4H 4S 4D 9S 9D";
-        final String fullOf5By8 = "5H 5S 5D 8S 8D";
+        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 fullVsSquare() {
-        final String full = "4S 5H 4S 5D 4H";
-        final String squareOf3 = "3S 3H 2S 3D 3H";
+        String full = "4S 5H 4S 5D 4H";
+        String squareOf3 = "3S 3H 2S 3D 3H";
         assertEquals(Arrays.asList(squareOf3), new Poker(Arrays.asList(full, squareOf3)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void twoSquares() {
-        final String squareOf2 = "2S 2H 2S 8D 2H";
-        final String squareOf5 = "4S 5H 5S 5D 5H";
+        String squareOf2 = "2S 2H 2S 8D 2H";
+        String squareOf5 = "4S 5H 5S 5D 5H";
         assertEquals(Arrays.asList(squareOf5), new Poker(Arrays.asList(squareOf2, squareOf5)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void squareVsStraightFlush() {
-        final String squareOf5 = "4S 5H 5S 5D 5H";
-        final String straightFlushTo9 = "5S 7S 8S 9S 6S";
+        String squareOf5 = "4S 5H 5S 5D 5H";
+        String straightFlushTo9 = "5S 7S 8S 9S 6S";
         assertEquals(Arrays.asList(straightFlushTo9), new Poker(Arrays.asList(squareOf5, straightFlushTo9)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void twoStraightFlushes() {
-        final String straightFlushTo8 = "4H 6H 7H 8H 5H";
-        final String straightFlushTo9 = "5S 7S 8S 9S 6S";
+        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());
     }
 
     @Ignore("Remove to run test")
     @Test
     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";
+        String spadeStraightTo9 = "9S 8S 7S 6S 5S";
+        String diamondStraightTo9 = "9D 8D 7D 6D 5D";
+        String threeOf4 = "4D 4S 4H QS KS";
         assertEquals(Arrays.asList(spadeStraightTo9, diamondStraightTo9), new Poker(Arrays.asList(spadeStraightTo9, diamondStraightTo9, threeOf4)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void straightTo5AgainstAPairOfJacks() {
-        final String straightTo5 = "2S 4D 5C 3S AS";
-        final String twoJacks = "JD 8D 7D JC 5D";
+        String straightTo5 = "2S 4D 5C 3S AS";
+        String twoJacks = "JD 8D 7D JC 5D";
         assertEquals(Arrays.asList(straightTo5), new Poker(Arrays.asList(straightTo5, twoJacks)).getBestHands());
     }
 }