trackler 2.0.6.40 → 2.0.6.41

data/tracks/clojure/.gitignore

@@ -4,6 +4,7 @@
 tmp
 bin/configlet
 bin/configlet.exe
+x-common
 
 pom.xml
 pom.xml.asc

data/tracks/clojure/_src/clock_generator.clj

@@ -0,0 +1,5 @@
+(ns clock-generator)
+
+(defn munge-data
+  [test-data]
+  test-data)

data/tracks/clojure/_src/generator.clj

@@ -0,0 +1,72 @@
+(ns generator
+  (:require [cheshire.core :as json]
+            [clojure.java.shell :refer [sh]]
+            [clojure.java.io :refer [reader]]
+            [stencil.core :as stencil])
+  (:import (java.io File IOException)))
+
+(defn file-exists?
+  "Helper function to determine if a given file exists."
+  [path]
+  (.exists (File. path)))
+
+(defn warn-and-exit
+  "Wrapper function to warn with the given message and then exit with a non-zero return"
+  [message]
+  (println message)
+  (System/exit 1))
+
+(defn clone-test-data
+  "Clone the x-common repo from github"
+  []
+  (sh "git" "clone" "git@github.com:exercism/x-common"))
+
+(defn load-test-data
+  "Clones and loads the test data for the given exercise"
+  [exercise-name]
+  (when-not (file-exists? "x-common")
+    (clone-test-data))
+  (let [test-data-filename (format "x-common/exercises/%s/canonical-data.json" exercise-name)]
+    (when-not (file-exists? test-data-filename)
+      (warn-and-exit
+       (format "Could not find test data for %s (looking in %s)"
+               exercise-name test-data-filename)))
+    (json/parse-stream (reader test-data-filename))))
+
+(defn munge-test-data
+  "Loads the generator namespace for the exercise and calls the munge-data function on the given test-data."
+  [exercise-name test-data]
+  (let [exercise-ns (symbol (str exercise-name "-generator"))]
+    (try
+      (require [exercise-ns])
+      (if-let [munge-data-fn (ns-resolve exercise-ns (symbol "munge-data"))]
+        (munge-data-fn test-data)
+        (do
+          (println (format "No munge-data function defined in %s" exercise-ns))
+          (println (format "Skipping any munging of canonical-data for %s" exercise-name))
+          test-data))
+      (catch IOException e
+        (println (format "Could not require %s due to an exception:\n\t%s" exercise-ns (.getMessage e)))
+        (println (format "Skipping any munging of canonical-data for %s" exercise-name))
+        test-data))))
+
+(defn generate-test-data
+  "Munges the test-data and renders the test for the exercise using the test template."
+  [exercise-name test-template-path test-data]
+  (let [munged-test-data (munge-test-data exercise-name test-data)
+        template (slurp test-template-path)]
+    (spit
+     (format "exercises/%s/test/%s_test.clj" exercise-name exercise-name)
+     (stencil/render-string template munged-test-data))))
+
+(defn -main
+  "Uses the test template for the exercise and test data to generate test cases."
+  [exercise-name & args]
+  (let [test-template-path (format "exercises/%s/%s.mustache" exercise-name exercise-name)
+        test-data (load-test-data exercise-name)]
+    (if (file-exists? test-template-path)
+      (do
+        (generate-test-data exercise-name test-template-path test-data)
+        (println (format "Generated tests for %s exercise using template %s" exercise-name test-template-path)))
+      (warn-and-exit (format "No exercise test template found at '%s'" test-template-path))))
+  (shutdown-agents))

data/tracks/clojure/config.json

@@ -7,6 +7,7 @@
 
   ],
   "ignored": [
+    "_src",
     "_test",
     "docs",
     "target",
@@ -61,6 +62,11 @@
       "slug": "phone-number",
       "topics": []
     },
+    {
+      "difficulty": 1,
+      "slug": "clock",
+      "topics": []
+    },
     {
       "difficulty": 1,
       "slug": "grade-school",

data/tracks/clojure/exercises/clock/clock.mustache

@@ -0,0 +1,34 @@
+(ns clock-test
+  (:require [clock :refer :all]
+            [clojure.test :refer [deftest testing is]]))
+
+(deftest create-clock-test
+{{#create}}
+  {{#cases}}
+
+  (testing "{{{description}}}"
+    (let [test-clock (clock->string (clock {{{hour}}} {{{minute}}}))]
+      (is (= test-clock "{{{expected}}}")))){{/cases}}{{/create}})
+
+(deftest add-time-test
+{{#add}}
+  {{#cases}}
+
+  (testing "{{{description}}}"
+    (let [test-clock (clock->string (add-time (clock {{{hour}}} {{{minute}}}) {{{add}}}))]
+      (is (= test-clock "{{{expected}}}")))){{/cases}}{{/add}})
+
+(deftest equal-clock-test
+{{#equal}}
+  {{#cases}}
+  (testing "{{{description}}}"
+    (let [{{#clock1}}clock1 (clock {{{hour}}} {{{minute}}}){{/clock1}}
+          {{#clock2}}clock2 (clock {{{hour}}} {{{minute}}}){{/clock2}}]
+      {{#expected}}
+      (is (= clock1 clock2))))
+      {{/expected}}
+      {{^expected}}
+      (is (not= clock1 clock2))))
+      {{/expected}}
+    {{/cases}}
+{{/equal}})

data/tracks/clojure/exercises/clock/project.clj

@@ -0,0 +1,4 @@
+(defproject clock "0.1.0-SNAPSHOT"
+  :description "clock exercise."
+  :url "https://github.com/exercism/xclojure/tree/master/exercises/clock"
+  :dependencies [[org.clojure/clojure "1.8.0"]])

data/tracks/clojure/exercises/clock/src/example.clj

@@ -0,0 +1,19 @@
+(ns clock)
+
+(defn clock
+  "Return a 24 hour clock representation of the given hours and minutes."
+  [in-hour in-minute]
+  (let [total-minutes (mod (+ (* in-hour 60) in-minute) (* 60 24))
+        hours (mod (quot total-minutes 60) 24)
+        minutes (mod total-minutes 60)]
+    {:hour hours :minute minutes}))
+
+(defn clock->string
+  "Print the HH:MM representation of a clock."
+  [in-clock]
+  (format "%02d:%02d" (:hour in-clock) (:minute in-clock)))
+
+(defn add-time
+  "Add minutes to the given clock."
+  [in-clock minutes-to-add]
+  (clock (:hour in-clock) (+ (:minute in-clock) minutes-to-add)))

data/tracks/clojure/exercises/clock/test/clock_test.clj

@@ -0,0 +1,177 @@
+(ns clock-test
+  (:require [clock :refer :all]
+            [clojure.test :refer [deftest testing is]]))
+
+(deftest create-clock-test
+
+  (testing "on the hour"
+    (let [test-clock (clock->string (clock 8 0))]
+      (is (= test-clock "08:00"))))
+  (testing "past the hour"
+    (let [test-clock (clock->string (clock 11 9))]
+      (is (= test-clock "11:09"))))
+  (testing "midnight is zero hours"
+    (let [test-clock (clock->string (clock 24 0))]
+      (is (= test-clock "00:00"))))
+  (testing "hour rolls over"
+    (let [test-clock (clock->string (clock 25 0))]
+      (is (= test-clock "01:00"))))
+  (testing "hour rolls over continuously"
+    (let [test-clock (clock->string (clock 100 0))]
+      (is (= test-clock "04:00"))))
+  (testing "sixty minutes is next hour"
+    (let [test-clock (clock->string (clock 1 60))]
+      (is (= test-clock "02:00"))))
+  (testing "minutes roll over"
+    (let [test-clock (clock->string (clock 0 160))]
+      (is (= test-clock "02:40"))))
+  (testing "minutes roll over continuously"
+    (let [test-clock (clock->string (clock 0 1723))]
+      (is (= test-clock "04:43"))))
+  (testing "hour and minutes roll over"
+    (let [test-clock (clock->string (clock 25 160))]
+      (is (= test-clock "03:40"))))
+  (testing "hour and minutes roll over continuously"
+    (let [test-clock (clock->string (clock 201 3001))]
+      (is (= test-clock "11:01"))))
+  (testing "hour and minutes roll over to exactly midnight"
+    (let [test-clock (clock->string (clock 72 8640))]
+      (is (= test-clock "00:00"))))
+  (testing "negative hour"
+    (let [test-clock (clock->string (clock -1 15))]
+      (is (= test-clock "23:15"))))
+  (testing "negative hour rolls over"
+    (let [test-clock (clock->string (clock -25 0))]
+      (is (= test-clock "23:00"))))
+  (testing "negative hour rolls over continuously"
+    (let [test-clock (clock->string (clock -91 0))]
+      (is (= test-clock "05:00"))))
+  (testing "negative minutes"
+    (let [test-clock (clock->string (clock 1 -40))]
+      (is (= test-clock "00:20"))))
+  (testing "negative minutes roll over"
+    (let [test-clock (clock->string (clock 1 -160))]
+      (is (= test-clock "22:20"))))
+  (testing "negative minutes roll over continuously"
+    (let [test-clock (clock->string (clock 1 -4820))]
+      (is (= test-clock "16:40"))))
+  (testing "negative hour and minutes both roll over"
+    (let [test-clock (clock->string (clock -25 -160))]
+      (is (= test-clock "20:20"))))
+  (testing "negative hour and minutes both roll over continuously"
+    (let [test-clock (clock->string (clock -121 -5810))]
+      (is (= test-clock "22:10")))))
+
+(deftest add-time-test
+
+  (testing "add minutes"
+    (let [test-clock (clock->string (add-time (clock 10 0) 3))]
+      (is (= test-clock "10:03"))))
+  (testing "add no minutes"
+    (let [test-clock (clock->string (add-time (clock 6 41) 0))]
+      (is (= test-clock "06:41"))))
+  (testing "add to next hour"
+    (let [test-clock (clock->string (add-time (clock 0 45) 40))]
+      (is (= test-clock "01:25"))))
+  (testing "add more than one hour"
+    (let [test-clock (clock->string (add-time (clock 10 0) 61))]
+      (is (= test-clock "11:01"))))
+  (testing "add more than two hours with carry"
+    (let [test-clock (clock->string (add-time (clock 0 45) 160))]
+      (is (= test-clock "03:25"))))
+  (testing "add across midnight"
+    (let [test-clock (clock->string (add-time (clock 23 59) 2))]
+      (is (= test-clock "00:01"))))
+  (testing "add more than one day (1500 min = 25 hrs)"
+    (let [test-clock (clock->string (add-time (clock 5 32) 1500))]
+      (is (= test-clock "06:32"))))
+  (testing "add more than two days"
+    (let [test-clock (clock->string (add-time (clock 1 1) 3500))]
+      (is (= test-clock "11:21"))))
+  (testing "subtract minutes"
+    (let [test-clock (clock->string (add-time (clock 10 3) -3))]
+      (is (= test-clock "10:00"))))
+  (testing "subtract to previous hour"
+    (let [test-clock (clock->string (add-time (clock 10 3) -30))]
+      (is (= test-clock "09:33"))))
+  (testing "subtract more than an hour"
+    (let [test-clock (clock->string (add-time (clock 10 3) -70))]
+      (is (= test-clock "08:53"))))
+  (testing "subtract across midnight"
+    (let [test-clock (clock->string (add-time (clock 0 3) -4))]
+      (is (= test-clock "23:59"))))
+  (testing "subtract more than two hours"
+    (let [test-clock (clock->string (add-time (clock 0 0) -160))]
+      (is (= test-clock "21:20"))))
+  (testing "subtract more than two hours with borrow"
+    (let [test-clock (clock->string (add-time (clock 6 15) -160))]
+      (is (= test-clock "03:35"))))
+  (testing "subtract more than one day (1500 min = 25 hrs)"
+    (let [test-clock (clock->string (add-time (clock 5 32) -1500))]
+      (is (= test-clock "04:32"))))
+  (testing "subtract more than two days"
+    (let [test-clock (clock->string (add-time (clock 2 20) -3000))]
+      (is (= test-clock "00:20")))))
+
+(deftest equal-clock-test
+  (testing "clocks with same time"
+    (let [clock1 (clock 15 37)
+          clock2 (clock 15 37)]
+      (is (= clock1 clock2))))
+  (testing "clocks a minute apart"
+    (let [clock1 (clock 15 36)
+          clock2 (clock 15 37)]
+      (is (not= clock1 clock2))))
+  (testing "clocks an hour apart"
+    (let [clock1 (clock 14 37)
+          clock2 (clock 15 37)]
+      (is (not= clock1 clock2))))
+  (testing "clocks with hour overflow"
+    (let [clock1 (clock 10 37)
+          clock2 (clock 34 37)]
+      (is (= clock1 clock2))))
+  (testing "clocks with hour overflow by several days"
+    (let [clock1 (clock 3 11)
+          clock2 (clock 99 11)]
+      (is (= clock1 clock2))))
+  (testing "clocks with negative hour"
+    (let [clock1 (clock 22 40)
+          clock2 (clock -2 40)]
+      (is (= clock1 clock2))))
+  (testing "clocks with negative hour that wraps"
+    (let [clock1 (clock 17 3)
+          clock2 (clock -31 3)]
+      (is (= clock1 clock2))))
+  (testing "clocks with negative hour that wraps multiple times"
+    (let [clock1 (clock 13 49)
+          clock2 (clock -83 49)]
+      (is (= clock1 clock2))))
+  (testing "clocks with minute overflow"
+    (let [clock1 (clock 0 1)
+          clock2 (clock 0 1441)]
+      (is (= clock1 clock2))))
+  (testing "clocks with minute overflow by several days"
+    (let [clock1 (clock 2 2)
+          clock2 (clock 2 4322)]
+      (is (= clock1 clock2))))
+  (testing "clocks with negative minute"
+    (let [clock1 (clock 2 40)
+          clock2 (clock 3 -20)]
+      (is (= clock1 clock2))))
+  (testing "clocks with negative minute that wraps"
+    (let [clock1 (clock 4 10)
+          clock2 (clock 5 -1490)]
+      (is (= clock1 clock2))))
+  (testing "clocks with negative minute that wraps multiple times"
+    (let [clock1 (clock 6 15)
+          clock2 (clock 6 -4305)]
+      (is (= clock1 clock2))))
+  (testing "clocks with negative hours and minutes"
+    (let [clock1 (clock 7 32)
+          clock2 (clock -12 -268)]
+      (is (= clock1 clock2))))
+  (testing "clocks with negative hours and minutes that wrap"
+    (let [clock1 (clock 18 7)
+          clock2 (clock -54 -11513)]
+      (is (= clock1 clock2))))
+)

data/tracks/clojure/project.clj

@@ -2,5 +2,8 @@
   :description  "Exercism Exercises in Clojure"
   :url          "https://github.com/exercism/xclojure"
   :test-paths   ["_test"]
+  :source-paths ["_src"]
+  :aliases {"generate" ["run" "-m" "generator"]}
   :dependencies [[org.clojure/clojure "1.8.0"]
-                 [cheshire            "5.5.0"]])
+                 [cheshire            "5.5.0"]
+                 [stencil             "0.5.0"]])

data/tracks/csharp/exercises/poker/Example.cs

@@ -52,7 +52,7 @@ public static class Poker
 
         if (ranks.SequenceEqual(new[] { 14, 5, 4, 3, 2 }))
         {
-            ranks = new[] { 1, 2, 3, 4, 5 };
+            ranks = new[] { 5, 4, 3, 2, 1 };
         }
         
         var flush = suits.Distinct().Count() == 1;

data/tracks/csharp/exercises/poker/PokerTest.cs

@@ -168,4 +168,14 @@ public class PokerTest
         Assert.That(Poker.BestHands(new[] { spadeStraightTo9, diamondStraightTo9, threeOf4 }),
             Is.EqualTo(new[] { spadeStraightTo9, diamondStraightTo9 }));
     }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Straight_to_5_against_a_pair_of_jacks()
+    {
+        const string straightTo5 = "2S 4D 5C 3S AS";
+        const string twoJacks = "JD 8D 7D JC 5D";
+        Assert.That(Poker.BestHands(new[] { straightTo5, twoJacks }),
+            Is.EqualTo(new[] { straightTo5 }));
+    }
 }

data/tracks/erlang/docs/INSTALLATION.md

@@ -1,3 +1,6 @@
+If you have any trouble installing erlang please consider joining the 
+[gitter support channel](https://gitter.im/exercism/xerlang)
+
 ### Homebrew for Mac OS X
 
 Update your Homebrew to latest:
@@ -18,8 +21,15 @@ via `brew` are welcome).
 
 ### On Linux
 
-Fedora 17+ and Fedora Rawhide: `sudo yum -y install erlang`
-Arch Linux : Erlang is available on AUR via `yaourt -S erlang`
+* Fedora 17+ and Fedora Rawhide: `sudo yum -y install erlang`
+* Arch Linux: Erlang is available on AUR via `yaourt -S erlang`
+* Ubuntu/Debian: `sudo apt-get install erlang`
+
+It may happen that the packages above are dated. At least for ubuntu 16.04
+it should still be able to run the tests. If your package gets to old (older
+than OTP 17.0) please consider a build from source or using [`kerl`](https://github.com/kerl/kerl)
+or [`asdf-vm`](https://github.com/asdf-vm/asdf) and [`asdf-erlang`](https://github.com/asdf-vm/asdf-erlang)
+instead (follow installation instructions in the corresponding repositories).
 
 Also fetch the latest `rebar3` from rebar3.org and put it somewhere in
 your `$PATH` and make it executable. (PRs that describe this better or
@@ -37,4 +47,5 @@ choco install rebar3
 
 ### Installing from Source
 
-Get [Erlang OTP 17.1](http://www.erlang.org/download.html)
+Get [a recent Erlang OTP](http://www.erlang.org/download.html) and follow their
+[build-instructions](https://github.com/erlang/otp/blob/maint/HOWTO/INSTALL.md).

data/tracks/erlang/docs/LEARNING.md

@@ -1,5 +1,6 @@
 Exercism provides exercises and feedback but can be difficult to jump into for those learning Erlang for the first time. These resources can help you get started:
 
+* [Exercism related BEAM support channel on gitter](https://gitter.im/exercism/xerlang)
 * [Erlang Documentation](http://www.erlang.org/doc.html)
 * [Learn You Some Erlang for Great Good](http://learnyousomeerlang.com)
 * [StackOverflow](http://stackoverflow.com/)

data/tracks/go/exercises/gigasecond/gigasecond_test.go

@@ -16,10 +16,13 @@ const (
 	fmtDT = "2006-01-02T15:04:05"
 )
 
-func TestAddGigasecond(t *testing.T) {
+func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {
-		t.Fatalf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
 	}
+}
+
+func TestAddGigasecond(t *testing.T) {
 	for _, tc := range addCases {
 		in := parse(tc.in, t)
 		want := parse(tc.want, t)

data/tracks/go/exercises/grade-school/example.go

@@ -2,6 +2,8 @@ package school
 
 import "sort"
 
+const testVersion = 1
+
 type School map[int][]string
 
 func New() *School {

data/tracks/go/exercises/grade-school/grade_school_test.go

@@ -19,6 +19,14 @@ import (
 	"testing"
 )
 
+const targetTestVersion = 1
+
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
+	}
+}
+
 func TestNewSchoolIsEmpty(t *testing.T) {
 	if len(New().Enrollment()) != 0 {
 		t.Error("New school not empty")

data/tracks/go/exercises/hamming/hamming_test.go

@@ -6,7 +6,7 @@ const targetTestVersion = 5
 
 func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {
-		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+		t.Fatalf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
 	}
 }
 

data/tracks/go/exercises/hello-world/hello_test.go

@@ -9,6 +9,12 @@ import "testing"
 
 const targetTestVersion = 3
 
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
+	}
+}
+
 func TestHelloWorld(t *testing.T) {
 	tests := []struct {
 		name, expected string
@@ -22,8 +28,4 @@ func TestHelloWorld(t *testing.T) {
 			t.Fatalf("HelloWorld(%s) = %v, want %v", test.name, observed, test.expected)
 		}
 	}
-
-	if testVersion != targetTestVersion {
-		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
-	}
 }

data/tracks/haskell/exercises/accumulate/src/Accumulate.hs

@@ -1,4 +1,4 @@
 module Accumulate (accumulate) where
 
 accumulate :: (a -> b) -> [a] -> [b]
-accumulate = error "You need to implement this function."
+accumulate f xs = error "You need to implement this function."

data/tracks/haskell/exercises/anagram/src/Anagram.hs

@@ -1,4 +1,4 @@
 module Anagram (anagramsFor) where
 
 anagramsFor :: String -> [String] -> [String]
-anagramsFor = error "You need to implement this function."
+anagramsFor xs xss = error "You need to implement this function."

data/tracks/java/bin/journey-test.sh

@@ -72,6 +72,8 @@ get_operating_system() {
           echo "linux";;
       (Windows*)
           echo "windows";;
+      (MINGW*)
+          echo "windows";;
       (*)
           echo "linux";;
   esac
@@ -102,10 +104,25 @@ download_exercism_cli() {
   # "curl..." :: HTTP 302 headers, including "Location" -- URL to redirect to.
   # "awk..." :: pluck last path segment from "Location" (i.e. the version number)
   local version="$(curl --head --silent ${latest} | awk -v FS=/ '/Location:/{print $NF}' | tr -d '\r')"
-  local download_url=${CLI_RELEASES}/download/${version}/exercism-${os}-${arch}.tgz
+
+  local download_url_suffix
+  local unzip_command
+  local unzip_from_file_option
+  if [[ ${os} == "windows" ]] ; then
+    download_url_suffix="zip"
+    unzip_command="unzip -d"
+    unzip_from_file_option=""
+  else
+    download_url_suffix="tgz"
+    unzip_command="tar xz -C"
+    unzip_from_file_option="-f"
+  fi
+  local download_url=${CLI_RELEASES}/download/${version}/exercism-${os}-${arch}.${download_url_suffix}
 
   mkdir -p ${exercism_home}
-  curl -s --location ${download_url} | tar xz -C ${exercism_home}
+  local temp=`mktemp`
+  curl -s --location ${download_url} > ${temp}
+  ${unzip_command} ${exercism_home} ${unzip_from_file_option} ${temp}
   echo "<<< download_exercism_cli()"
 }
 
@@ -192,8 +209,8 @@ solve_all_exercises() {
 
   local xjava=$( pwd )
   local exercism_cli="./exercism --config ${exercism_configfile}"
-  local exercises=`cat config.json | jq '.problems []' --raw-output`
-  local total_exercises=`cat config.json | jq '.problems | length'`
+  local exercises=`cat config.json | jq '.exercises[].slug + " "' --join-output`
+  local total_exercises=`cat config.json | jq '.exercises | length'`
   local current_exercise_number=1
   local tempfile="${TMPDIR:-/tmp}/journey-test.sh-unignore_all_tests.txt"
 

data/tracks/java/exercises/allergies/src/example/java/Allergen.java

@@ -0,0 +1,20 @@
+public enum Allergen {
+    EGGS(1),
+    PEANUTS(2),
+    SHELLFISH(4),
+    STRAWBERRIES(8),
+    TOMATOES(16),
+    CHOCOLATE(32),
+    POLLEN(64),
+    CATS(128);
+
+    private final int score;
+
+    Allergen(int score) {
+        this.score = score;
+    }
+
+    public int getScore() {
+        return score;
+    }
+}

data/tracks/java/exercises/hamming/src/test/java/HammingTest.java

@@ -3,10 +3,15 @@ import static org.junit.Assert.*;
 
 import org.junit.Test;
 import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.rules.ExpectedException;
 
 public class HammingTest {
     
 
+    @Rule
+    public ExpectedException thrown = ExpectedException.none();
+    
     @Test
     public void testNoDifferenceBetweenIdenticalStrands() {
         assertThat(Hamming.compute("A", "A"), is(0));
@@ -37,14 +42,16 @@ public class HammingTest {
     }
 
     @Ignore
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public void testValidatesFirstStrandNotLonger() {
-        Hamming.compute("AAAG", "AAA");
+        thrown.expect(IllegalArgumentException.class);
+        Hamming.compute("AAAG", "AAA");                
     }
 
     @Ignore
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public void testValidatesOtherStrandNotLonger() {
+        thrown.expect(IllegalArgumentException.class);
         Hamming.compute("AAA", "AAAG");
     }
 

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

@@ -9,10 +9,17 @@ final class LuhnValidator {
     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
@@ -23,21 +30,22 @@ final class LuhnValidator {
             }
 
             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();
     }
 
 }