Merge branch 'master' of git://github.com/exercism/java into rna-transcription

exercises/largest-series-product/src/test/java/LargestSeriesProductCalculatorTest.java

 
     @Test
     public void testCorrectlyCalculatesLargestProductWhenSeriesLengthEqualsStringToSearchLength() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("29");
-        final long expectedProduct = 18;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("29");
+        long expectedProduct = 18;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLengthTwoWithNumbersInOrder() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
-        final long expectedProduct = 72;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
+        long expectedProduct = 72;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLengthTwoWithNumbersNotInOrder() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("576802143");
-        final long expectedProduct = 48;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("576802143");
+        long expectedProduct = 48;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLengthThreeWithNumbersInOrder() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
-        final long expectedProduct = 504;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
+        long expectedProduct = 504;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLengthThreeWithNumbersNotInOrder() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("1027839564");
-        final long expectedProduct = 270;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("1027839564");
+        long expectedProduct = 270;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLengthFiveWithNumbersInOrder() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
-        final long expectedProduct = 15120;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
+        long expectedProduct = 15120;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(5);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(5);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductInLongStringToSearchV1() {
-        final LargestSeriesProductCalculator calculator
+        LargestSeriesProductCalculator calculator
                 = new LargestSeriesProductCalculator("73167176531330624919225119674426574742355349194934");
 
-        final long expectedProduct = 23520;
+        long expectedProduct = 23520;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(6);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(6);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfZeroIfAllDigitsAreZeroes() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0000");
-        final long expectedProduct = 0;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0000");
+        long expectedProduct = 0;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfZeroIfAllSeriesOfGivenLengthContainZero() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("99099");
-        final long expectedProduct = 0;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("99099");
+        long expectedProduct = 0;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testSeriesLengthLongerThanLengthOfStringToTestIsRejected() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("123");
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("123");
 
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage(
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLength0ForEmptyStringToSearch() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("");
-        final long expectedProduct = 1;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("");
+        long expectedProduct = 1;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(0);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(0);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLength0ForNonEmptyStringToSearch() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("123");
-        final long expectedProduct = 1;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("123");
+        long expectedProduct = 1;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(0);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(0);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testEmptyStringToSearchAndSeriesOfNonZeroLengthIsRejected() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("");
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("");
 
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage(
     @Ignore("Remove to run test")
     @Test
     public void testNegativeSeriesLengthIsRejected() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("12345");
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("12345");
 
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("Series length must be non-negative.");

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

 
     @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);
     }
     @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);
     }
     @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);
     }
     @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);
     }
     @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);
     }
     @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);
     }
     @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);
     }
     @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);
     }
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithSingleColumnAndTwoMines() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 " ",
                 "*",
                 " ",
                 " "
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 "1",
                 "*",
                 "2",
                 "1"
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithSingleColumnAndTwoMinesAtEdges() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 "*",
                 " ",
                 " ",
                 "*"
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 "*",
                 "1",
                 " ",
                 "*"
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithMinesInCross() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 "  *  ",
                 "  *  ",
                 "*****",
                 "  *  "
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 " 2*2 ",
                 "25*52",
                 "*****",
                 " 2*2 "
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
     @Ignore("Remove to run test")
     @Test
     public void testLargeInputBoard() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 " *  * ",
                 "  *   ",
                 "    * ",
                 "      "
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 "1*22*1",
                 "12*322",
                 " 123*2",
                 "111111"
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }