Merge pull request #289 from exercism/luhn-update-test-suite

luhn: update to latest canonical tests

exercises/luhn/src/example/java/LuhnValidator.java

     boolean isValid(final String candidate) {
         final String sanitizedCandidate = SPACE_PATTERN.matcher(candidate).replaceAll("");
 
+        if (sanitizedCandidate.length() <= 1) {
+            return false;
+        }
+
+        // We need to alter every second digit counting from the right. Reversing makes this easy!
+        final String reversedSanitizedCandidate = reverse(sanitizedCandidate);
+
         final List<Integer> computedDigits = new ArrayList<>();
 
-        for (int charIndex = 0; charIndex < sanitizedCandidate.length(); charIndex++) {
-            int inputDigit = Character.digit(sanitizedCandidate.charAt(charIndex), 10);
+        for (int charIndex = 0; charIndex < reversedSanitizedCandidate.length(); charIndex++) {
+            int inputDigit = Character.digit(reversedSanitizedCandidate.charAt(charIndex), 10);
 
             /*
              * Character.digit returns a negative int if the supplied character does not represent a digit with respect
             }
 
             if (charIndex % 2 == 1) {
-                /*
-                 * Since our doubled input digit must lie in [2, 18], the operation
-                 *
-                 *   "subtract 9 from the doubled input digit if it exceeds 9 in value"
-                 *
-                 * is equivalent to applying the modulo operation below universally.
-                 */
-                inputDigit = (2 * inputDigit) % 9;
+                inputDigit = 2 * inputDigit;
+
+                if (inputDigit > 9) {
+                    inputDigit -= 9;
+                }
             }
 
             computedDigits.add(inputDigit);
         }
 
         final int digitSum = computedDigits.stream().mapToInt(Integer::intValue).sum();
-        return digitSum > 0 && digitSum % 10 == 0;
+        return digitSum % 10 == 0;
+    }
+
+    private String reverse(final String string) {
+        return new StringBuilder(string).reverse().toString();
     }
 
 }

exercises/luhn/src/test/java/LuhnValidatorTest.java

 
     @Ignore
     @Test
-    public void testThatAValidCanadianSocialInsuranceNumberIsIdentifiedAsValid() {
+    public void testThatASimpleValidNumberIsIdentifiedAsValid() {
+        assertTrue(new LuhnValidator().isValid(" 5 9 "));
+    }
+
+    @Ignore
+    @Test
+    public void testThatAValidCanadianSocialInsuranceNumberIsIdentifiedAsValidV1() {
         assertTrue(new LuhnValidator().isValid("046 454 286"));
     }
 
     @Ignore
     @Test
+    public void testThatAValidCanadianSocialInsuranceNumberIsIdentifiedAsValidV2() {
+        assertTrue(new LuhnValidator().isValid("055 444 285"));
+    }
+
+    @Ignore
+    @Test
     public void testThatAnInvalidCanadianSocialInsuranceNumberIsIdentifiedAsInvalid() {
         assertFalse(new LuhnValidator().isValid("046 454 287"));
     }
         assertFalse(new LuhnValidator().isValid("046a 454 286"));
     }
 
+    @Ignore
+    @Test
+    public void testThatStringContainingPunctuationIsInvalid() {
+        assertFalse(new LuhnValidator().isValid("055-444-285"));
+    }
+
+    @Ignore
+    @Test
+    public void testThatStringContainingSymbolsIsInvalid() {
+        assertFalse(new LuhnValidator().isValid("055£ 444$ 285"));
+    }
+
+    @Ignore
+    @Test
+    public void testThatTheStringConsistingOfASpaceAndASingleZeroIsInvalid() {
+        assertFalse(new LuhnValidator().isValid(" 0"));
+    }
+
+    @Ignore
+    @Test
+    public void testThatStringContainingMultipleZerosIsValid() {
+        assertTrue(new LuhnValidator().isValid(" 00000"));
+    }
+
+    @Ignore
+    @Test
+    public void testThatDoublingNineIsHandledCorrectly() {
+        assertTrue(new LuhnValidator().isValid("091"));
+    }
+
 }