update palindrome-products

exercises/palindrome-products/.meta/src/reference/java/PalindromeCalculator.java

 public class PalindromeCalculator {
 
     public SortedMap<Long, List<List<Integer>>> getPalindromeProductsWithFactors(int minFactor, int maxFactor) {
-    	if(minFactor > maxFactor) throw new IllegalArgumentException("invalid input: min is " + minFactor + " and max is " + maxFactor);
+    	if(minFactor > maxFactor) {
+    		throw new IllegalArgumentException("invalid input: min is " + minFactor + " and max is " + maxFactor);
+    	}
     	
         SortedMap<Long, List<List<Integer>>> palindromeSortedList = new TreeMap<>();
         long num;
             }
         }
         
-        if(palindromeSortedList.size() == 0) throw new NoSuchElementException("no palindrome with factors in the range " + minFactor + " to " + maxFactor);
+        if(palindromeSortedList.size() == 0) {
+    		throw new NoSuchElementException("no palindrome with factors in the range " + minFactor + " to " + maxFactor);
+    	}
         
         return Collections.unmodifiableSortedMap(palindromeSortedList);
     }

exercises/palindrome-products/src/test/java/PalindromeCalculatorTest.java

     
     @Test
     public void smallestPalindromeFromSingleDigitFactors() {
-        final List<List<Integer>> expected = Collections.unmodifiableList(
+        List<List<Integer>> expected = Collections.unmodifiableList(
                 Arrays.asList(
                         Arrays.asList(1, 1)
                 )
         );
-        final long expectedValue = 1l;
+        long expectedValue = 1l;
 
-        final SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(1, 9);
+        SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(1, 9);
 
         checkPalindromeWithFactorsMatchesExpected(expected, expectedValue, palindromes, palindromes.firstKey());
     }
     @Ignore("Remove to run test")
     @Test
     public void largestPalindromeFromSingleDigitFactors() {
-        final List<List<Integer>> expected = Collections.unmodifiableList(
+        List<List<Integer>> expected = Collections.unmodifiableList(
                 Arrays.asList(
                         Arrays.asList(1, 9),
                         Arrays.asList(3, 3)
                 )
         );
-        final long expectedValue = 9l;
+        long expectedValue = 9l;
 
-        final SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(1, 9);
+        SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(1, 9);
 
         checkPalindromeWithFactorsMatchesExpected(expected, expectedValue, palindromes, palindromes.lastKey());
     }
     @Ignore("Remove to run test")
     @Test
     public void largestPalindromeFromDoubleDigitFactors() {
-        final List<List<Integer>> expected = Collections.unmodifiableList(
+        List<List<Integer>> expected = Collections.unmodifiableList(
                 Arrays.asList(
                         Arrays.asList(91, 99)
                 )
         );
-        final long expectedValue = 9009l;
+        long expectedValue = 9009l;
 
-        final SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(10, 99);
+        SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(10, 99);
 
         checkPalindromeWithFactorsMatchesExpected(expected, expectedValue, palindromes, palindromes.lastKey());
     }
     @Ignore("Remove to run test")
     @Test
     public void smallestPalindromeFromDoubleDigitFactors() {
-        final List<List<Integer>> expected = Collections.unmodifiableList(
+        List<List<Integer>> expected = Collections.unmodifiableList(
                 Arrays.asList(
                         Arrays.asList(11, 11)
                 )
         );
-        final long expectedValue = 121l;
+        long expectedValue = 121l;
 
-        final SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(10, 99);
+        SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(10, 99);
 
         checkPalindromeWithFactorsMatchesExpected(expected, expectedValue, palindromes, palindromes.firstKey());
     }
     @Ignore("Remove to run test")
     @Test
     public void largestPalindromeFromTripleDigitFactors() {
-        final List<List<Integer>> expected = Collections.unmodifiableList(
+        List<List<Integer>> expected = Collections.unmodifiableList(
                 Arrays.asList(
                         Arrays.asList(913, 993)
                 )
         );
-        final long expectedValue = 906609l;
+        long expectedValue = 906609l;
 
-        final SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(100, 999);
+        SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(100, 999);
 
         checkPalindromeWithFactorsMatchesExpected(expected, expectedValue, palindromes, palindromes.lastKey());
     }
     @Ignore("Remove to run test")
     @Test
     public void smallestPalindromeFromTripleDigitFactors() {
-        final List<List<Integer>> expected = Collections.unmodifiableList(
+        List<List<Integer>> expected = Collections.unmodifiableList(
                 Arrays.asList(
                         Arrays.asList(101, 101)
                 )
         );
-        final long expectedValue = 10201l;
+        long expectedValue = 10201l;
 
-        final SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(100, 999);
+        SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(100, 999);
 
         checkPalindromeWithFactorsMatchesExpected(expected, expectedValue, palindromes, palindromes.firstKey());
     }
     @Ignore("Remove to run test")
     @Test
     public void smallestPalindromeFromQuadDigitFactors() {
-        final List<List<Integer>> expected = Collections.unmodifiableList(
+        List<List<Integer>> expected = Collections.unmodifiableList(
                 Arrays.asList(
                         Arrays.asList(1001, 1001)
                 )
         );
-        final long expectedValue = 1002001l;
+        long expectedValue = 1002001l;
 
-        final SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(1000, 9999);
+        SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(1000, 9999);
 
         checkPalindromeWithFactorsMatchesExpected(expected, expectedValue, palindromes, palindromes.firstKey());
     }
     @Ignore("Remove to run test")
     @Test
     public void largestPalindromeFromQuadDigitFactors() {
-        final List<List<Integer>> expected = Collections.unmodifiableList(
+        List<List<Integer>> expected = Collections.unmodifiableList(
                 Arrays.asList(
                         Arrays.asList(9901, 9999)
                 )
         );
-        final long expectedValue = 99000099l;
+        long expectedValue = 99000099l;
 
-        final SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(1000, 9999);
+        SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(1000, 9999);
 
         checkPalindromeWithFactorsMatchesExpected(expected, expectedValue, palindromes, palindromes.lastKey());
     }
         expectedException.expect(NoSuchElementException.class);
         expectedException.expectMessage("no palindrome with factors in the range 1002 to 1003");
 
-        final SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(1002, 1003);
+        SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(1002, 1003);
     }
     
     @Ignore("Remove to run test")
         expectedException.expect(NoSuchElementException.class);
         expectedException.expectMessage("no palindrome with factors in the range 15 to 15");
 
-        final SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(15, 15);
+        SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(15, 15);
     }
     
     @Ignore("Remove to run test")
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("invalid input: min is 10000 and max is 1");
 
-        final SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(10000, 1);
+        SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(10000, 1);
     }
     
     @Ignore("Remove to run test")
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("invalid input: min is 2 and max is 1");
 
-        final SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(2, 1);
+        SortedMap<Long, List<List<Integer>>> palindromes = palindromeCalculator.getPalindromeProductsWithFactors(2, 1);
     }