Merge branch 'master' into transpose

.github/stale.yml

-# Issues or Pull Requests with these labels will never be considered stale
-exemptLabels:
-  - "first-timers only"
-  - "good first patch"
-  - "policy"
-
-# Label to use when marking as stale
-staleLabel: stale

.gitignore

 *.iml
 bin/configlet
 bin/configlet.exe
-gradle/
 /exercises/.nb-gradle/

.travis.yml

 jdk:
   - oraclejdk8
 
-notifications:
-  webhooks:
-    urls:
-      - https://webhooks.gitter.im/e/5e9ccd41111917b19478
-    on_success: change  # options: [always|never|change] default: always
-    on_failure: always  # options: [always|never|change] default: always
-    on_start: never     # options: [always|never|change] default: always
-
 # http://docs.travis-ci.com/user/migrating-from-legacy
 sudo: false
-cache: bundler
+
 addons:
   apt:
     packages:
   - rvm use 2.2.5
   - bin/build-jq.sh  # we want jq 1.5 features; not avail through pkg repo.
 
+# https://docs.travis-ci.com/user/customizing-the-build#Skipping-the-Installation-Step
+install: true  # if we don't skip install, ./gradlew assemble is invoked, but this task is not available.
+
 before_script:
   - export PATH=$TRAVIS_BUILD_DIR/bin:$PATH  # ensure our tools are prefered over included ones.
 
 script:
   - bin/unit-tests.sh
   - bin/journey-test.sh
+
+# configure caching (https://docs.travis-ci.com/user/languages/java/#Caching)
+before_cache:
+  - rm -f  $HOME/.gradle/caches/modules-2/modules-2.lock
+  - rm -fr $HOME/.gradle/caches/*/plugin-resolution/
+# format from https://docs.travis-ci.com/user/caching/#Enabling-multiple-caching-features
+cache:
+  bundler: true
+  directories:
+    - $HOME/.gradle/caches/
+    - $HOME/.gradle/wrapper/
+
+notifications:
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/5e9ccd41111917b19478
+    on_success: change  # options: [always|never|change] default: always
+    on_failure: always  # options: [always|never|change] default: always
+    on_start: never     # options: [always|never|change] default: always

LICENSE

-The MIT License (MIT)
+MIT License
 
-Copyright (c) 2014 Katrina Owen, _@kytrinyx.com
+Copyright (c) 2017 Exercism, Inc
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

POLICIES.md

 
 > Most (all?) exercises should be implemented in the form of instance methods since they contain "domain logic" and we (Exercism) want to encourage exemplary software.
 
-References: [[1](https://github.com/exercism/xjava/issues/177#issuecomment-261291741)]
+References: [[1](https://github.com/exercism/java/issues/177#issuecomment-261291741)]
 
 ### Starter implementations
 
     `throw new UnsupportedOperationException("Delete this statement and provide your own implementation.");`
 > - Exercises 21+: provide no stubs, but mention any "interesting" interface aspects in the HINT.md file (which gets merged into the README.md for the exercise).
 
-References: [[1](https://github.com/exercism/xjava/issues/178)]
+References: [[1](https://github.com/exercism/java/issues/178)]
+
+### Do not make user-facing classes `final`
+
+> Starter implementations and test classes should not include the `final` keyword in class declarations as it isn't strictly necessary and could be confusing to people unfamiliar with Java.
 
 ### Ignore noninitial tests
 
 > All but the first test in an exercise test suite should be annotated `@Ignore("Remove to run test")` (single test) or `@Ignore("Remove to run tests")` (parametrized test).
 
-References: [[1](https://github.com/exercism/xjava/issues/101#issuecomment-249349204)]
+References: [[1](https://github.com/exercism/java/issues/101#issuecomment-249349204)]
 
 ### Multiple file submissions
 
 > The first exercise in the track whose test suite mandates multiple solution files should be accompanied by a HINT.md file reminding the practitioner that the CLI supports multiple file submissions.
 
-References: [[1](https://github.com/exercism/xjava/issues/365#issuecomment-292533120)]
+References: [[1](https://github.com/exercism/java/issues/365#issuecomment-292533120)]
 
 ### Good first patches
 
-> Aim to keep 10-20 small and straightforward issues open at eny given time. Identify any such issues by applying the "Good first patch" label. You can view the current list of these issues [here](https://github.com/exercism/xjava/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+patch%22).
+> Aim to keep 10-20 small and straightforward issues open at eny given time. Identify any such issues by applying the "Good first patch" label. You can view the current list of these issues [here](https://github.com/exercism/java/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+patch%22).
 
-References: [[1](https://github.com/exercism/xjava/issues/220#issue-196447088)]
+References: [[1](https://github.com/exercism/java/issues/220#issue-196447088)]
 
 ### Simple onboarding
 
 > The Installing Java instructions should seek to minimize the number of steps and the number of concepts a new-to-the-track practitioner needs to learn to get to coding.
 
-References: [[1](https://github.com/exercism/xjava/issues/395#issue-215734887)]
+References: [[1](https://github.com/exercism/java/issues/395#issue-215734887)]

README.md

-# xJava [![Build Status](https://travis-ci.org/exercism/xjava.svg?branch=master)](https://travis-ci.org/exercism/xjava) [![Join the chat at https://gitter.im/exercism/xjava](https://badges.gitter.im/exercism/xjava.svg)](https://gitter.im/exercism/xjava?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+# java [![Build Status](https://travis-ci.org/exercism/java.svg?branch=master)](https://travis-ci.org/exercism/java) [![Join the chat at https://gitter.im/exercism/xjava](https://badges.gitter.im/exercism/java.svg)](https://gitter.im/exercism/xjava?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 Source for Exercism Exercises in Java.
 
 ## Contributing Guide
 
-For general information about how to contribute to Exercism, please refer to the [Contributing Guide](https://github.com/exercism/x-api/blob/master/CONTRIBUTING.md#the-exercise-data).
+For general information about how to contribute to Exercism, please refer to the [Contributing Guide](https://github.com/exercism/docs/blob/master/contributing-to-language-tracks).
 
 ## Table of Contents
 
 1. **Ensure you have the basic Java tooling installed:**  JDK 1.8+, an editor and Gradle 2.x.
 
    (see [exercism.io: Installing Java](http://exercism.io/languages/java/installing))
--  **Setup a branch on a fork of [exercism/xjava](https://github.com/exercism/xjava) on your computer.**
+-  **Setup a branch on a fork of [exercism/java](https://github.com/exercism/java) on your computer.**
 
-   See [GitHub Help: Forking](https://help.github.com/articles/fork-a-repo/).  Use those instructions (in conjunction with [Exercism Contributing Guide](https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md#git-basics)) to:
+   See [GitHub Help: Forking](https://help.github.com/articles/fork-a-repo/).  Use those instructions (in conjunction with the [Git Basics doc](https://github.com/exercism/docs/blob/master/contributing-to-language-tracks/git-basics.md)) to:
    * "fork" a repository on GitHub;
    - install `git`;
    - "clone" a copy of your fork;
-   - configure an "upstream remote" (in this case, `exercism/xjava`);
+   - configure an "upstream remote" (in this case, `exercism/java`);
    - create a branch to house your work
 -  **Write the codes.**  Do your work on that branch you just created.
 
    $ git push
    ```
 
-   [Exercism Contributing Guide :: Commit Messages](https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md#commit-messages) provides practical advice on crafting meaningful commit messages.
+   The Git Basics doc has a section on [commit messages](https://github.com/exercism/docs/blob/master/contributing-to-language-tracks/git-basics.md#commit-messages) that provides practical advice on crafting meaningful commit messages.
 -  **Verify that your work passes all tests.**  When you create a pull request (PR), GitHub triggers a build on Travis CI.  Your PR will not be merged unless those tests pass.
 
 ## Getting Familiar With the Codebase
 
 There are two objectives to the design of this build:
 
-1. when a problem is built from within the xjava repo, the tests run against the "example" code (i.e. when you, the contributor, are developing the exercise);
-2. when a problem is built outside the xjava repo (when a participant is solving the exercise), the tests run against the "main" code.
+1. when a problem is built from within the `exercism/java` repo (i.e. when you, the contributor, are developing the exercise), the tests run against the "example" code;
+2. when a problem is built outside the `exercism/java` repo (when a participant is solving the exercise), the tests run against the "main" code.
 
 This repo is a multi-project gradle build.
 
 
 This is the top-level module, contained in the `exercises` directory.  It is a container for the problem sub-modules.
 
-  * it's `build.gradle` points the "main" sourceset to the example code.
-  * it's `settings.gradle` names each of the subprojects, one for each problem in the set.
+  * its `build.gradle` points the "main" sourceset to the example code.
+  * its `settings.gradle` names each of the subprojects, one for each problem in the set.
 
 ### The Problem Submodules
 
 The `exercises` subdirectory contains all of the problem submodules.
 Each problem/submodule is a subdirectory of the same name as its slug.
 
-  * it's `build.gradle` names dependencies required to work that problem.
+  * its `build.gradle` names dependencies required to work that problem.
 
 Each problem/submodule has three source sets:
 
 2015-09-06 15:21:01 - JSON::GeneratorError - source sequence is illegal/malformed utf-8:
 ```
 
-This is because some files generated by the build can't be served from the x-api.  This is by design: the CLI does not serve binaries.  To fix this, simply make sure you do a clean in your `xjava` repo before you fetch:
+This is because some files generated by the build can't be served from the x-api.  This is by design: the CLI does not serve binaries.  To fix this, simply make sure you do a clean in your `exercism/java` repo before you fetch:
 
 ```
-cd ~/workspace/exercism/xjava/exercises
+cd ~/workspace/exercism/java/exercises
 gradle clean
 cd ~/workspace/exercism/exercises
 exercism fetch java bob
 ```
-
-
-# License
-
-The MIT License (MIT)
-
-Copyright (c) 2014 Katrina Owen, _@kytrinyx.com

exercises/_template/build.gradle → _template/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

bin/fetch-configlet

-#!/bin/bash
+#!/usr/bin/env bash
 
 LATEST=https://github.com/exercism/configlet/releases/latest
 

bin/journey-test.sh

 #!/usr/bin/env bash
 
+# This script is shared between the Java and Kotlin tracks.  If you make an update to this script on
+# one track, please create a companion PR to merge it in to the other.  Thank you!
+TRACK=java
+TRACK_REPO="$TRACK"
+TRACK_SRC_EXT="java"
+
 on_exit() {
   echo ">>> on_exit()"
   if [[ "$xapi_pid" != "" ]] ; then
 
   if [[ "`which $binary`" == "" ]]; then
     echo "${binary} not found; it is required to perform this test."
-    echo -e "Have you completed the setup instructions at https://github.com/exercism/xjava ?\n"
+    echo -e "Have you completed the setup instructions at https://github.com/exercism/${TRACK_REPO} ?\n"
     echo "PATH=${PATH}"
     echo "aborting."
     exit 1
   if [[ "${expected_ruby_ver}" != "" && "${current_ruby_ver}" != "${expected_ruby_ver}" ]]; then
     echo "${ruby_app_home} requires Ruby ${expected_ruby_ver}; current Ruby version is ${current_ruby_ver}."
     echo -e "Ruby used: `which ruby`.\n"
-    echo -e "Have you completed the setup instructions at https://github.com/exercism/xjava ?\n"
+    echo -e "Have you completed the setup instructions at https://github.com/exercism/${TRACK_REPO} ?\n"
     echo "PATH=${PATH}"
     echo "aborting."
     exit 1
     rm -rf "${build_path}"
   fi
   cd exercises
-  gradle clean
+  "$EXECPATH"/gradlew clean
   cd ..
   echo "<<< clean()"
 }
   local xapi_home="$2"
   echo ">>> make_local_trackler(trackler=\"${trackler}\", xapi_home=\"${xapi_home}\")"
 
-  local xjava=$( pwd )
+  local track_root=$( pwd )
   pushd ${trackler}
 
   # Get the version of Trackler x-api is currently using
   git submodule init -- common
   git submodule update
 
-  # Bake in local copy of xjava; this is what we are testing.
-  rmdir tracks/java
-  mkdir -p tracks/java/exercises
-  cp ${xjava}/config.json tracks/java
-  cp -r ${xjava}/exercises tracks/java
+  # Bake in local copy of this track; this is what we are testing.
+  rmdir tracks/${TRACK}
+  mkdir -p tracks/${TRACK}/exercises
+  cp ${track_root}/config.json tracks/${TRACK}
+  cp -r ${track_root}/exercises tracks/${TRACK}
 
   gem install bundler
   bundle install
   local exercism_configfile="$2"
   echo ">>> solve_all_exercises(exercism_exercises_dir=\"${exercism_exercises_dir}\", exercism_configfile=\"${exercism_configfile}\")"
 
-  local xjava=$( pwd )
+  local track_root=$( pwd )
   local exercism_cli="./exercism --config ${exercism_configfile}"
   local exercises=`cat config.json | jq '.exercises[].slug + " "' --join-output`
   local total_exercises=`cat config.json | jq '.exercises | length'`
     echo "${current_exercise_number} of ${total_exercises} -- ${exercise}"
     echo "=================================================="
 
-    ${exercism_cli} fetch java $exercise
-    cp -R -H ${xjava}/exercises/${exercise}/src/example/java/* ${exercism_exercises_dir}/java/${exercise}/src/main/java/
+    ${exercism_cli} fetch ${TRACK} $exercise
+    cp -R -H ${track_root}/exercises/${exercise}/src/example/${TRACK}/* ${exercism_exercises_dir}/${TRACK}/${exercise}/src/main/${TRACK}/
 
-    pushd ${exercism_exercises_dir}/java/${exercise}
+    pushd ${exercism_exercises_dir}/${TRACK}/${exercise}
     # Check that tests compile before we strip @Ignore annotations
-    gradle compileTestJava
+    "$EXECPATH"/gradlew compileTestJava
     # Ensure we run all the tests (as delivered, all but the first is @Ignore'd)
-    for testfile in `find . -name "*Test.java"`; do
-      sed 's/@Ignore\(.*\)//' ${testfile} > "${tempfile}" && mv "${tempfile}" "${testfile}"
+    for testfile in `find . -name "*Test.${TRACK_SRC_EXT}"`; do
+      # Strip @Ignore annotations to ensure we run the tests (as delivered, all but the first is @Ignore'd).
+      # Note that unit-test.sh also strips @Ignore annotations via the Gradle task copyTestsFilteringIgnores.
+      # The stripping implementations here and in copyTestsFilteringIgnores should be kept consistent.
+      sed 's/@Ignore\(\(.*\)\)\{0,1\}//' ${testfile} > "${tempfile}" && mv "${tempfile}" "${testfile}"
     done
-    gradle test
+    "$EXECPATH"/gradlew test
     popd
 
     current_exercise_number=$((current_exercise_number + 1))
   # all functions assume current working directory is repository root.
   cd "${SCRIPTPATH}/.."
 
-  local xjava=$( pwd )
+  local track_root=$( pwd )
   local build_dir="build"
-  local build_path="${xjava}/${build_dir}"
+  local build_path="${track_root}/${build_dir}"
 
   local xapi_home="${build_path}/x-api"
   local trackler_home="${build_path}/trackler"
   local xapi_port=9292
 
   # fail fast if required binaries are not installed.
-  assert_installed "gradle"
   assert_installed "jq"
 
   clean "${build_dir}"
 
-  # Make a version of trackler that includes the source from this repo.
+  # Make a local version of trackler that includes the source from this repo.
   git_clone "x-api" "${xapi_home}"
   git_clone "trackler" "${trackler_home}"
   assert_ruby_installed "${trackler_home}"

bin/unit-tests.sh

-#!/bin/bash
+#!/usr/bin/env bash
 set -e
-gradle --version
+./gradlew --version
 
 echo ""
 echo ">>> Running configlet..."
 pushd exercises
 echo ""
 echo ">>> Running tests..."
-TERM=dumb gradle check compileStarterSourceJava --continue
+TERM=dumb ../gradlew check compileStarterSourceJava --parallel --continue
 popd
 

config.json

 {
   "slug": "java",
   "language": "Java",
-  "repository": "https://github.com/exercism/xjava",
+  "repository": "https://github.com/exercism/java",
   "active": true,
-
   "exercises": [
     {
       "slug": "hello-world",
       "difficulty": 1,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "rna-transcription",
       "difficulty": 2,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "pangram",
       "difficulty": 3,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "hamming",
       "difficulty": 3,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "gigasecond",
       "difficulty": 3,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "space-age",
       "difficulty": 3,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "acronym",
       "difficulty": 3,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "scrabble-score",
       "difficulty": 3,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "raindrops",
       "difficulty": 3,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "difference-of-squares",
       "difficulty": 3,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "secret-handshake",
       "difficulty": 3,
-      "topics": []
+      "topics": [
+
+      ]
+    },
+    {
+      "slug": "perfect-numbers",
+      "difficulty": 3,
+      "topics": [
+
+      ]
     },
     {
       "slug": "sum-of-multiples",
       "difficulty": 4,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "luhn",
       "difficulty": 4,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "matrix",
       "difficulty": 4,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "triangle",
       "difficulty": 4,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "largest-series-product",
       "difficulty": 4,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "sieve",
       "difficulty": 4,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "twelve-days",
       "difficulty": 4,
-      "topics": []
+      "topics": [
+
+      ]
+    },
+    {
+      "slug": "kindergarten-garden",
+      "difficulty": 4,
+      "topics": [
+
+      ]
+    },
+    {
+      "slug": "collatz-conjecture",
+      "difficulty": 4,
+      "topics": [
+
+      ]
     },
     {
       "slug": "nth-prime",
       "difficulty": 4,
-      "topics": []
+      "topics": [
+
+      ]
+    },
+    {
+      "slug": "saddle-points",
+      "difficulty": 4,
+      "topics": [
+
+      ]
     },
     {
       "slug": "diamond",
       "difficulty": 4,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "isogram",
       "difficulty": 4,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "flatten-array",
       "difficulty": 5,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "pig-latin",
       "difficulty": 5,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "phone-number",
       "difficulty": 5,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "nucleotide-count",
       "difficulty": 5,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "word-count",
       "difficulty": 5,
-      "topics": []
+      "topics": [
+
+      ]
+    },
+    {
+      "slug": "run-length-encoding",
+      "difficulty": 5,
+      "topics": [
+
+      ]
     },
     {
       "slug": "robot-name",
       "difficulty": 5,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "prime-factors",
       "difficulty": 5,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "allergies",
       "difficulty": 5,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "bob",
       "difficulty": 5,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "pascals-triangle",
       "difficulty": 5,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "bracket-push",
       "difficulty": 5,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "series",
       "difficulty": 5,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "atbash-cipher",
       "difficulty": 5,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "roman-numerals",
       "difficulty": 6,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "beer-song",
       "difficulty": 6,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "queen-attack",
       "difficulty": 6,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "etl",
       "difficulty": 6,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "linked-list",
       "difficulty": 6,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "grade-school",
       "difficulty": 6,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "robot-simulator",
       "difficulty": 6,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "binary-search",
       "difficulty": 6,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "minesweeper",
       "difficulty": 6,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "wordy",
       "difficulty": 6,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "all-your-base",
       "difficulty": 6,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "anagram",
       "difficulty": 7,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "sublist",
       "difficulty": 7,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
-      "slug": "simple-linked-list",
+      "slug": "word-search",
       "difficulty": 7,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
-      "slug": "binary-search-tree",
+      "slug": "simple-linked-list",
       "difficulty": 7,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
-      "slug": "rectangles",
+      "slug": "binary-search-tree",
       "difficulty": 7,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "meetup",
       "difficulty": 7,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
       "slug": "crypto-square",
       "difficulty": 7,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
-      "slug": "simple-cipher",
-      "difficulty": 8,
-      "topics": []
+      "slug": "clock",
+      "difficulty": 7,
+      "topics": [
+
+      ]
     },
     {
-      "slug": "palindrome-products",
+      "slug": "ocr-numbers",
       "difficulty": 8,
-      "topics": []
-    },
-    {
-      "slug": "pythagorean-triplet",
-      "difficulty": 9,
-      "topics": []
+      "topics": [
+
+      ]
     },
     {
-      "slug": "custom-set",
-      "difficulty": 10,
-      "topics": []
+      "slug": "rectangles",
+      "difficulty": 8,
+      "topics": [
+
+      ]
     },
     {
-      "slug": "clock",
-      "difficulty": 1,
-      "topics": []
+      "slug": "book-store",
+      "difficulty": 8,
+      "topics": [
+
+      ]
     },
     {
-      "slug": "perfect-numbers",
-      "difficulty": 1,
-      "topics": []
+      "slug": "simple-cipher",
+      "difficulty": 8,
+      "topics": [
+
+      ]
     },
     {
       "slug": "change",
-      "difficulty": 1,
-      "topics": []
-    },
-    {
-      "slug": "list-ops",
-      "difficulty": 1,
-      "topics": []
-    },
-    {
-      "slug": "ocr-numbers",
-      "difficulty": 1,
-      "topics": []
+      "difficulty": 8,
+      "topics": [
+
+      ]
     },
     {
-      "slug": "book-store",
-      "difficulty": 1,
-      "topics": []
+      "slug": "palindrome-products",
+      "difficulty": 8,
+      "topics": [
+
+      ]
     },
     {
-      "slug": "saddle-points",
-      "difficulty": 1,
-      "topics": []
+      "slug": "pythagorean-triplet",
+      "difficulty": 9,
+      "topics": [
+
+      ]
     },
     {
-      "slug": "run-length-encoding",
-      "difficulty": 1,
-      "topics": []
+      "slug": "custom-set",
+      "difficulty": 10,
+      "topics": [
+
+      ]
     },
     {
-      "slug": "kindergarten-garden",
+      "slug": "list-ops",
       "difficulty": 1,
-      "topics": []
+      "topics": [
+      
+      ]
     },
     {
       "slug": "transpose",
       "difficulty": 1,
-      "topics": []
+      "topics": [
+      
+      ]
     }
   ],
   "deprecated": [
     "strain",
     "trinary"
   ],
-  "ignored": [
-    "_template",
-    ".gradle",
-    "build",
-    "docs",
-    "gradle",
-    "scripts"
-  ],
   "foregone": [
     "leap",
     "grains",
     "say"
   ]
 }
-

docs/MAINTAINING.md

 
 - [Your Permissions](#your-permissions)
 - [Maintainer Guides](#maintainer-guides)
-- [The Project Board](#the-project-board)
 - [Miscellaneous](#miscellaneous)
 
 ## Your Permissions 
 
-As a maintainer, you have write access to four repositories.  "write access" means you can: review, reject, accept and merge PRs; and push changes to these repos.  Despite having permissions to push directly, we tend to seek review of even our own PRs.
+As a maintainer, you have write access to several repositories.  "write access" means you can: review, reject, accept and merge PRs; and push changes to these repos.  Despite having permissions to push directly, we tend to seek review of even our own PRs.
 
 ### Track-specific
 
-- [xjava](https://github.com/exercism/xjava) — yeah... you know what this one is. :)
+- [java](https://github.com/exercism/java) — yeah... you know what this one is. :)
 
 ### Exercism-wide
 
-- [x-common](https://github.com/exercism/x-common) — the library of canonical exercises.
+- [problem-specifications](https://github.com/exercism/problem-specifications) — the library of canonical exercises.
 - [discussions](https://github.com/exercism/discussions) — the place where project-wide conversations happen. 
   [issues sorted by most recently updated.](https://github.com/exercism/discussions/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc)
-- [todo](https://github.com/exercism/todo) — not really used... might just go away completely in the future.
+- [docs](https://github.com/exercism/docs) - the place to find project-wide documentation.
 
 ## Maintainer Guides
 
 - [exercism.io/docs/getting-involved-in-a-track.md](https://github.com/exercism/exercism.io/blob/master/docs/getting-involved-in-a-track.md)
 - [exercism.io/docs/reviewing-a-pull-request.md](https://github.com/exercism/exercism.io/blob/master/docs/reviewing-a-pull-request.md)
 
-## The Project Board
-
-GitHub issues are great, but there's no way to easily set priorities.
-To do this, we're using a GitHub Project: https://github.com/exercism/xjava/projects/2.
-
-- **Epics** — issues that really represent bigger ideas.  These inspire creating a set of smaller issues to be elaborated...
-- **Icebox** — issues that just needs a little more detail to be "ready to play"...
-- **Backlog** — issues ready to be worked.  When we start working on an issue, we move it to the next column...
-- **Current** — issues in progress.  When we've considered it done, we move the card to...
-- **Delivered** — completed issues that could use another pair of eyes.  When these are reviewed they get moved to...
-- **Done** — issues we've complete.  Every so often, we get together and it's nice to review what we've completed. 
-  Once reviewed, we remove them from this Project.
-
-The point of this board is to make clear our shared priorities.  It's a tool you can use.
-However, if you have an idea and want to implement it, you can just do it; it does not have to be added to this board.
-
 ## Miscellaneous
 
 - Issues marked with "policy" are current "team agreements": [exercism?label:policy](https://github.com/search?q=org%3Aexercism+label%3Apolicy).

docs/TESTS.md

    C:\Users\JohnDoe>gradle test
    ```
    *(Don't worry about the tests failing, at first, this is how you begin each exercise.)*
-5. Solve the exercise.  Find and work through the `GETTING_STARTED.md` guide ([view on GitHub](https://github.com/exercism/xjava/blob/master/exercises/hello-world/GETTING_STARTED.md)).
+5. Solve the exercise.  Find and work through the `GETTING_STARTED.md` guide ([view on GitHub](https://github.com/exercism/java/blob/master/exercises/hello-world/GETTING_STARTED.md)).
 
 
 Good luck!  Have fun!
   $ gradle test
   ```
    *(Don't worry about the tests failing, at first, this is how you begin each exercise.)*
-4. Solve the exercise.  Find and work through the `GETTING_STARTED.md` guide ([view on GitHub](https://github.com/exercism/xjava/blob/master/exercises/hello-world/GETTING_STARTED.md)).
+4. Solve the exercise.  Find and work through the `GETTING_STARTED.md` guide ([view on GitHub](https://github.com/exercism/java/blob/master/exercises/hello-world/GETTING_STARTED.md)).
 
 Good luck!  Have fun!
 
   $ gradle test
   ```
    *(Don't worry about the tests failing, at first, this is how you begin each exercise.)*
-4. Solve the exercise.  Find and work through the `GETTING_STARTED.md` guide ([view on GitHub](https://github.com/exercism/xjava/blob/master/exercises/hello-world/GETTING_STARTED.md)).
+4. Solve the exercise.  Find and work through the `GETTING_STARTED.md` guide ([view on GitHub](https://github.com/exercism/java/blob/master/exercises/hello-world/GETTING_STARTED.md)).
 
 Good luck!  Have fun!
 

exercises/accumulate/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/acronym/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/acronym/src/main/java/Acronym.java

-final class Acronym {
+class Acronym {
 
     Acronym(String phrase) {
         throw new UnsupportedOperationException("Delete this statement and write your own implementation.");

exercises/all-your-base/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/all-your-base/src/main/java/BaseConverter.java

-final class BaseConverter {
+class BaseConverter {
 
 
 

exercises/all-your-base/src/test/java/BaseConverterTest.java

 
 import static org.junit.Assert.assertArrayEquals;
 
+/*
+ * version: 1.1.0
+ */
 public class BaseConverterTest {
 
     /*
 
     @Ignore("Remove to run test")
     @Test
-    public void testNegativeDigit() {
+    public void testFirstBaseIsOne() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Digits may not be negative.");
+        expectedException.expectMessage("Bases must be at least 2.");
 
-        new BaseConverter(2, new int[]{1, -1, 1, 0, 1, 0});
+        new BaseConverter(1, new int[]{});
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testInvalidPositiveDigit() {
+    public void testFirstBaseIsZero() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("All digits must be strictly less than the base.");
+        expectedException.expectMessage("Bases must be at least 2.");
 
-        new BaseConverter(2, new int[]{1, 2, 1, 0, 1, 0});
+        new BaseConverter(0, new int[]{});
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testFirstBaseIsOne() {
+    public void testFirstBaseIsNegative() {
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("Bases must be at least 2.");
 
-        new BaseConverter(1, new int[]{});
+        new BaseConverter(-2, new int[]{});
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testSecondBaseIsOne() {
-        final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
-
+    public void testNegativeDigit() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Bases must be at least 2.");
+        expectedException.expectMessage("Digits may not be negative.");
 
-        baseConverter.convertToBase(1);
+        new BaseConverter(2, new int[]{1, -1, 1, 0, 1, 0});
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testFirstBaseIsZero() {
+    public void testInvalidPositiveDigit() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Bases must be at least 2.");
+        expectedException.expectMessage("All digits must be strictly less than the base.");
 
-        new BaseConverter(0, new int[]{});
+        new BaseConverter(2, new int[]{1, 2, 1, 0, 1, 0});
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testSecondBaseIsZero() {
+    public void testSecondBaseIsOne() {
         final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
 
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("Bases must be at least 2.");
 
-        baseConverter.convertToBase(0);
+        baseConverter.convertToBase(1);
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testFirstBaseIsNegative() {
+    public void testSecondBaseIsZero() {
+        final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
+
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("Bases must be at least 2.");
 
-        new BaseConverter(-2, new int[]{});
+        baseConverter.convertToBase(0);
     }
 
     @Ignore("Remove to run test")

exercises/allergies/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/anagram/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/atbash-cipher/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/beer-song/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/binary-search-tree/src/test/java/BSTTest.java

 
     @Test
     public void dataIsRetained() {
-        BST<Integer> sut = new BST();
+        BST<Integer> bst = new BST();
         final int actual = 4;
-        sut.insert(actual);
-        final BST.Node<Integer> root = sut.getRoot();
+        bst.insert(actual);
+        final BST.Node<Integer> root = bst.getRoot();
         assertNotNull(root);
         final int expected = root.getData();
         assertEquals(expected, actual);
     @Test
     @Ignore("Remove to run test")
     public void insertsLess() {
-        BST<Integer> sut = new BST();
+        BST<Integer> bst = new BST();
         final int expectedRoot = 4;
         final int expectedLeft = 2;
 
-        sut.insert(expectedRoot);
-        sut.insert(expectedLeft);
+        bst.insert(expectedRoot);
+        bst.insert(expectedLeft);
 
-        final BST.Node<Integer> root = sut.getRoot();
+        final BST.Node<Integer> root = bst.getRoot();
         assertNotNull(root);
         final BST.Node<Integer> left = root.getLeft();
         assertNotNull(left);
     @Test
     @Ignore("Remove to run test")
     public void insertsSame() {
-        BST<Integer> sut = new BST();
+        BST<Integer> bst = new BST();
         final int expectedRoot = 4;
         final int expectedLeft = 4;
 
-        sut.insert(expectedRoot);
-        sut.insert(expectedLeft);
+        bst.insert(expectedRoot);
+        bst.insert(expectedLeft);
 
-        final BST.Node<Integer> root = sut.getRoot();
+        final BST.Node<Integer> root = bst.getRoot();
         assertNotNull(root);
         final BST.Node<Integer> left = root.getLeft();
         assertNotNull(left);
     @Test
     @Ignore("Remove to run test")
     public void insertsRight() {
-        BST<Integer> sut = new BST();
+        BST<Integer> bst = new BST();
         final int expectedRoot = 4;
         final int expectedRight = 5;
 
-        sut.insert(expectedRoot);
-        sut.insert(expectedRight);
+        bst.insert(expectedRoot);
+        bst.insert(expectedRight);
 
-        final BST.Node<Integer> root = sut.getRoot();
+        final BST.Node<Integer> root = bst.getRoot();
         assertNotNull(root);
         final BST.Node<Integer> right = root.getRight();
         assertNotNull(right);
     @Test
     @Ignore("Remove to run test")
     public void createsComplexTree() {
-        BST<Integer> sut = new BST<>();
+        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(4, 2, 6, 1, 3, 5, 7)
         );
         List<Integer> treeData = Collections.unmodifiableList(
                 Arrays.asList(4, 2, 6, 1, 3, 7, 5)
         );
-        treeData.forEach(sut::insert);
+        treeData.forEach(bst::insert);
 
-        List<Integer> actual = sut.getAsLevelOrderList();
+        List<Integer> actual = bst.getAsLevelOrderList();
         assertEquals(expected, actual);
     }
 
     @Test
     @Ignore("Remove to run test")
     public void sortsSingleElement() {
-        BST<Integer> sut = new BST<>();
+        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Collections.singletonList(4)
         );
 
-        sut.insert(4);
+        bst.insert(4);
 
-        List<Integer> actual = sut.getAsSortedList();
+        List<Integer> actual = bst.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Test
     @Ignore("Remove to run test")
     public void sortsCollectionOfTwoIfSecondInsertedIsSmallerThanFirst() {
-        BST<Integer> sut = new BST<>();
+        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(2, 4)
         );
 
-        sut.insert(4);
-        sut.insert(2);
+        bst.insert(4);
+        bst.insert(2);
 
-        List<Integer> actual = sut.getAsSortedList();
+        List<Integer> actual = bst.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Test
     @Ignore("Remove to run test")
     public void sortsCollectionOfTwoIfSecondInsertedIsBiggerThanFirst() {
-        BST<Integer> sut = new BST<>();
+        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(4, 5)
         );
 
-        sut.insert(4);
-        sut.insert(5);
+        bst.insert(4);
+        bst.insert(5);
 
-        List<Integer> actual = sut.getAsSortedList();
+        List<Integer> actual = bst.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Test
     @Ignore("Remove to run test")
     public void iteratesOverComplexTree() {
-        BST<Integer> sut = new BST<>();
+        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(1, 2, 3, 4, 5, 6, 7)
         );
         List<Integer> treeData = Collections.unmodifiableList(
                 Arrays.asList(4, 2, 1, 3, 6, 7, 5)
         );
-        treeData.forEach(sut::insert);
+        treeData.forEach(bst::insert);
 
-        List<Integer> actual = sut.getAsSortedList();
+        List<Integer> actual = bst.getAsSortedList();
         assertEquals(expected, actual);
     }
 }

exercises/binary-search/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/binary-search/src/test/java/BinarySearchTest.java

 
+import org.junit.Ignore;
+import org.junit.Test;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+
 import static org.junit.Assert.assertEquals;
-import org.junit.Ignore;
-import org.junit.Test;
 
 public class BinarySearchTest {
 
-    public static final List<Integer> EMPTY_LIST
-            = Collections.unmodifiableList(new ArrayList<Integer>(0));
-
-    public static final List<Integer> LIST_OF_UNIT_LENGTH
-            = Collections.unmodifiableList(
-                    Arrays.asList(6)
-            );
-
-    private static final List<Integer> SORTED_LIST
-            = Collections.unmodifiableList(
-                    Arrays.asList(1, 3, 4, 6, 8, 9, 11)
-            );
-
-    public static final List<Integer> SORTED_LIST_OF_ODD_LENGTH
-            = Collections.unmodifiableList(
-                    Arrays.asList(1, 3, 5, 8, 13, 21, 34, 55,
-                            89, 144, 233, 377, 634)
-            );
-
-    public static final List<Integer> SORTED_LIST_OF_EVEN_LENGTH
-            = Collections.unmodifiableList(
-                    Arrays.asList(1, 3, 5, 8, 13, 21, 34, 55,
-                            89, 144, 233, 377)
-            );
-
     @Test
     public void findsAValueInAnArrayWithOneElement() {
-        BinarySearch<Integer> sut = new BinarySearch<>(LIST_OF_UNIT_LENGTH);
-        final int value = 6;
-        final int actual = sut.indexOf(value);
-        final int expected = 0;
-        assertEquals(expected, actual);
+        List<Integer> listOfUnitLength = Collections.singletonList(6);
+
+        BinarySearch<Integer> search = new BinarySearch<>(listOfUnitLength);
+
+        assertEquals(0, search.indexOf(6));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void findsAValueInTheMiddleOfAnArray() {
-        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST);
-        final int value = 6;
-        final int actual = sut.indexOf(value);
-        final int expected = 3;
-        assertEquals(expected, actual);
+        List<Integer> sortedList = Collections.unmodifiableList(
+                Arrays.asList(1, 3, 4, 6, 8, 9, 11)
+        );
+
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
+
+        assertEquals(3, search.indexOf(6));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void findsAValueAtTheBeginningOfAnArray() {
-        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST);
-        final int value = 1;
-        final int actual = sut.indexOf(value);
-        final int expected = 0;
-        assertEquals(expected, actual);
+        List<Integer> sortedList = Collections.unmodifiableList(
+                Arrays.asList(1, 3, 4, 6, 8, 9, 11)
+        );
+
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
+
+        assertEquals(0, search.indexOf(1));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void findsAValueAtTheEndOfAnArray() {
-        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST);
-        final int value = 11;
-        final int actual = sut.indexOf(value);
-        final int expected = 6;
-        assertEquals(expected, actual);
+        List<Integer> sortedList = Collections.unmodifiableList(
+                Arrays.asList(1, 3, 4, 6, 8, 9, 11)
+        );
+
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
+
+        assertEquals(6, search.indexOf(11));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void findsAValueInAnArrayOfOddLength() {
-        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST_OF_ODD_LENGTH);
-        final int value = 144;
-        final int actual = sut.indexOf(value);
-        final int expected = 9;
-        assertEquals(expected, actual);
+        List<Integer> sortedListOfOddLength = Collections.unmodifiableList(
+                Arrays.asList(1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 634)
+        );
+
+        BinarySearch<Integer> search = new BinarySearch<>(sortedListOfOddLength);
+
+        assertEquals(9, search.indexOf(144));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void findsAValueInAnArrayOfEvenLength() {
-        BinarySearch<Integer> sut
-                = new BinarySearch<>(SORTED_LIST_OF_EVEN_LENGTH);
-        final int value = 21;
-        final int actual = sut.indexOf(value);
-        final int expected = 5;
-        assertEquals(expected, actual);
+        List<Integer> sortedListOfEvenLength = Collections.unmodifiableList(
+                Arrays.asList(1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377)
+        );
+
+        BinarySearch<Integer> search = new BinarySearch<>(sortedListOfEvenLength);
+
+        assertEquals(5, search.indexOf(21));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void identifiesThatAValueIsNotIncludedInTheArray() {
-        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST);
-        final int value = 7;
-        final int actual = sut.indexOf(value);
-        final int expected = -1;
-        assertEquals(expected, actual);
+        List<Integer> sortedList = Collections.unmodifiableList(
+                Arrays.asList(1, 3, 4, 6, 8, 9, 11)
+        );
+
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
+
+        assertEquals(-1, search.indexOf(7));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void aValueSmallerThanTheArraysSmallestValueIsNotIncluded() {
-        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST);
-        final int value = 0;
-        final int actual = sut.indexOf(value);
-        final int expected = -1;
-        assertEquals(expected, actual);
+        List<Integer> sortedList = Collections.unmodifiableList(
+                Arrays.asList(1, 3, 4, 6, 8, 9, 11)
+        );
+
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
+
+        assertEquals(-1, search.indexOf(0));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void aValueLargerThanTheArraysSmallestValueIsNotIncluded() {
-        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST);
-        final int value = 13;
-        final int actual = sut.indexOf(value);
-        final int expected = -1;
-        assertEquals(expected, actual);
+        List<Integer> sortedList = Collections.unmodifiableList(
+                Arrays.asList(1, 3, 4, 6, 8, 9, 11)
+        );
+
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
+
+        assertEquals(-1, search.indexOf(13));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void nothingIsIncludedInAnEmptyArray() {
-        BinarySearch<Integer> sut = new BinarySearch<>(EMPTY_LIST);
-        final int value = 1;
-        final int actual = sut.indexOf(value);
-        final int expected = -1;
-        assertEquals(expected, actual);
+        List<Integer> emptyList = Collections.emptyList();
+
+        BinarySearch<Integer> search = new BinarySearch<>(emptyList);
+
+        assertEquals(-1, search.indexOf(1));
     }
 }

exercises/binary/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/bob/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/book-store/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/book-store/src/example/java/Bookstore.java → exercises/book-store/src/example/java/BookStore.java

 import java.util.List;
 import java.util.stream.Collectors;
 
-class Bookstore {
+class BookStore {
 
   private static final int BOOK_PRICE = 8, MAX_GROUP_SIZE = 5;
 
   private static double[] DISCOUNT_TIERS = {0, 5, 10, 20, 25};
 
-  private List<Integer> books;
-
-  Bookstore(List<Integer> books) {
-    this.books = books;
-  }
-
-  double calculateTotalCost() {
-    return calculateTotalCost(this.books, 0);
+  double calculateBasketCost(final List<Integer> books) {
+    return calculateBasketCost(books, 0);
   }
 
-  private double calculateTotalCost(List<Integer> books, double priceSoFar) {
+  private double calculateBasketCost(final List<Integer> books, final double priceSoFar) {
     if (books.size() == 0) {
       return priceSoFar;
     }
         remainingBooks.remove(newGroupBook);
       }
 
-      double price = calculateTotalCost(remainingBooks, priceSoFar + costOfGroupSize(newGroupBooks.size()));
-
+      double price = calculateBasketCost(remainingBooks, priceSoFar + costOfGroupSize(newGroupBooks.size()));
       minPrice = Math.min(minPrice, price);
     }
 

exercises/book-store/src/test/java/BookStoreTest.java

+import static org.junit.Assert.assertEquals;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Arrays;
+
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class BookStoreTest {
+
+  // This is sufficient accuracy since we're handling currency values, which should be equal to within 2 decimal places.
+  private static final double EQUALITY_TOLERANCE = 0.001;
+
+  private BookStore bookStore;
+
+  @Before
+  public void setUp() {
+    bookStore = new BookStore();
+  }
+
+  @Test
+  public void onlyASingleBook() {
+    List<Integer> books = Collections.singletonList(1);
+    assertEquals(8, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void twoOfSameBook() {
+    List<Integer> books = Arrays.asList(1, 1);
+    assertEquals(16, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void emptyBasket() {
+    List<Integer> books = Collections.emptyList();
+    assertEquals(0, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void twoDifferentBooks() {
+    List<Integer> books = Arrays.asList(1, 2);
+    assertEquals(15.20, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void threeDifferentBooks() {
+    List<Integer> books = Arrays.asList(1, 2, 3);
+    assertEquals(21.6, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void fourDifferentBooks() {
+    List<Integer> books = Arrays.asList(1, 2, 3, 4);
+    assertEquals(25.6, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void fiveDifferentBooks() {
+    List<Integer> books = Arrays.asList(1, 2, 3, 4, 5);
+    assertEquals(30, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void twoGroupsOfFourIsCheaperThanGroupOfFivePlusGroupOfThree() {
+    List<Integer> books = Arrays.asList(1, 1, 2, 2, 3, 3, 4, 5);
+    assertEquals(51.20, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void groupOfFourPlusGroupOfTwoIsCheaperThanTwoGroupsOfThree() {
+    List<Integer> books = Arrays.asList(1, 1, 2, 2, 3, 4);
+    assertEquals(40.8, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void twoEachOfFirst4BooksAnd1CopyEachOfRest() {
+    List<Integer> books = Arrays.asList(1, 1, 2, 2, 3, 3, 4, 4, 5);
+    assertEquals(55.60, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void twoCopiesOfEachBook() {
+    List<Integer> books = Arrays.asList(1, 1, 2, 2, 3, 3, 4, 4, 5, 5);
+    assertEquals(60.00, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void threeCopiesOfFirstBookAnd2EachOfRemaining() {
+    List<Integer> books = Arrays.asList(1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1);
+    assertEquals(68.00, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+  @Ignore("Remove to run test")
+  @Test
+  public void threeEachOFirst2BooksAnd2EachOfRemainingBooks() {
+    List<Integer> books = Arrays.asList(1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1, 2);
+    assertEquals(75.20, bookStore.calculateBasketCost(books), EQUALITY_TOLERANCE);
+  }
+
+}

exercises/book-store/src/test/java/BookstoreTest.java

-import static org.junit.Assert.assertEquals;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.ArrayList;
-import java.util.Arrays;
-
-import org.junit.Ignore;
-import org.junit.Test;
-
-public class BookstoreTest {
-
-  // This is sufficient accuracy since we're handling currency values, which should be equal to within 2 decimal places.
-  private static final double EQUALITY_TOLERANCE = 0.001;
-
-  @Test
-  public void onlyASingleBook() {
-    List<Integer> books = new ArrayList<>(Collections.singletonList(1));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(8, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void twoOfSameBook() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 1));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(16, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void emptyBasket() {
-    List<Integer> books = new ArrayList<>();
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(0, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void twoDifferentBooks() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 2));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(15.20, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void threeDifferentBooks() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 2, 3));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(21.6, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void fourDifferentBooks() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(25.6, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void fiveDifferentBooks() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(30, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void twoGroupsOfFourIsCheaperThanGroupOfFivePlusGroupOfThree() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 1, 2, 2, 3, 3, 4, 5));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(51.20, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void groupOfFourPlusGroupOfTwoIsCheaperThanTwoGroupsOfThree() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 1, 2, 2, 3, 4));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(40.8, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void twoEachOfFirst4BooksAnd1CopyEachOfRest() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 1, 2, 2, 3, 3, 4, 4, 5));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(55.60, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void twoCopiesOfEachBook() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 1, 2, 2, 3, 3, 4, 4, 5, 5));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(60.00, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void threeCopiesOfFirstBookAnd2EachOfRemaining() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(68.00, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-  @Ignore("Remove to run test")
-  @Test
-  public void threeEachOFirst2BooksAnd2EachOfRemainingBooks() {
-    List<Integer> books = new ArrayList<>(Arrays.asList(1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1, 2));
-    Bookstore bookstore = new Bookstore(books);
-    assertEquals(75.20, bookstore.calculateTotalCost(), EQUALITY_TOLERANCE);
-  }
-
-}

exercises/bracket-push/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/bracket-push/src/main/java/BracketChecker.java

-final class BracketChecker {
+class BracketChecker {
 
 
 

exercises/build.gradle

-subprojects { project ->
-  apply plugin: "java"
-
-  sourceSets {
-    // Verify that the tests are working by running them against the example code.
-    // By replacing the "main" sourceSet with the example code we avoid any collisions
-    //   with solution code that may have been included as a "starter" (e.g. etl).
-    main {
-      java.srcDirs = ["src/example/java"]
-    }
-    project["compileJava"].doFirst { compileTask ->
-      println "  (source = " + compileTask.source.asPath + ")"
-    }
+// This root Gradle project is used for:
+//
+// - Checking that every test suite compiles against its corresponding example implementation;
+// - Checking that every example implementation passes its corresponding test suite;
+// - Checking that every provided starter implementation compiles.
+//
+// This file is never delivered to Exercism users.
 
-    starterSource {
-      java.srcDirs = ["src/main/java"]
-    }
-    project["compileStarterSourceJava"].doFirst { compileTask ->
-      println "  (source = " + compileTask.source.asPath + ")"
-    }
+def generatedTestSourceDir = "build/gen/test/java"
 
-    // In lieu of being able to disable @Ignore in JUnit tests, we filter
-    // those annotations, placing the edited tests in the path named here.
-    test {
-      java.srcDirs = ["build/gen/test/java"]
-    }
-    project["compileTestJava"].doFirst { compileTask ->
-      println "  (source = " + compileTask.source.asPath + ")"
-    }
-  }
+subprojects {
 
+  // Add a task that copies test source files into a build directory. All @Ignore annotations
+  // are removed during this copying, so that when we run the copied tests, none are skipped and
+  // all should execute.
+  //
+  // Note that journey-test.sh also strips @Ignore annotations using sed. The
+  // stripping implementations here and in journey-test.sh should be kept
+  // consistent.
   task copyTestsFilteringIgnores(type: Copy) {
     from "src/test/java"
-    into "build/gen/test/java"
+    into generatedTestSourceDir
     filter { line ->
-      line.contains("@Ignore") ? "" : line
+      line.contains("@Ignore") ? null : line
+    }
+  }
+
+  afterEvaluate { project ->
+
+    sourceSets {
+      // Set the directory containing the example implementation as the default source set. Default
+      // compile tasks will now run against this source set.
+      main {
+        java.srcDirs = ["src/example/java"]
+      }
+
+      // Define a custom source set named "starterSource" that points to the starter implementations
+      // delivered to users. We can then use the generated "compileStarterSourceJava" task to verify
+      // that the starter source compiles as-is.
+      starterSource {
+        java.srcDirs = ["src/main/java"]
+      }
+
+      // Set the directory containing the @Ignore-stripped tests as the default test source set.
+      // Default test tasks will now run against this source set.
+      test {
+        java.srcDirs = [generatedTestSourceDir]
+      }
+
+      // Log the source paths associated with each source set to verify they are what we expect.
+      logCompileTaskSourcePath(project, "compileJava") // Corresponds to the "main" source set.
+      logCompileTaskSourcePath(project, "compileStarterSourceJava")
+      logCompileTaskSourcePath(project, "compileTestJava")
     }
+
+    // When running the standard test task, make sure we prepopulate the test source set with the
+    // @Ignore-stripped tests.
+    test.dependsOn(copyTestsFilteringIgnores)
   }
 
-  test.dependsOn(copyTestsFilteringIgnores)
+}
+
+def logCompileTaskSourcePath(Project project, String taskName) {
+  project[taskName].doFirst { compileTask ->
+    println "  (source = ${compileTask.source.asPath})"
+  }
 }

exercises/change/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/change/src/main/java/ChangeCalculator.java

-final class ChangeCalculator {
+class ChangeCalculator {
 
 
 

exercises/change/src/test/java/ChangeCalculatorTest.java

 import static java.util.Collections.singletonList;
 import static org.junit.Assert.assertEquals;
 
-public final class ChangeCalculatorTest {
+public class ChangeCalculatorTest {
 
     /*
      * See https://github.com/junit-team/junit4/wiki/Rules for information on JUnit Rules in general and

exercises/clock/HINT.md

+In order to satisfy the requirement that two clocks are considered equal just when they are set to the same time, you will need to override the [`equals`](https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#equals(java.lang.Object)) and [`hashcode`](https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#hashCode) methods in your `Clock` class.
+ 
+For more information on how to override these methods, see [this JavaWorld article](https://web.archive.org/web/20170528222153/http://www.javaworld.com/article/2072762/java-app-dev/object-equality.html).

exercises/clock/build.gradle

 dependencies {
     testCompile "junit:junit:4.12"
 }
+
 test {
     testLogging {
         exceptionFormat = 'full'
         events = ["passed", "failed", "skipped"]
     }
-}
+}

exercises/clock/src/test/java/ClockAddTest.java

 
 import static org.junit.Assert.assertEquals;
 
+/*
+ * version: 1.0.1
+ */
 public class ClockAddTest {
 
     @Ignore("Remove to run test")

exercises/clock/src/test/java/ClockCreationTest.java

 
 import static org.junit.Assert.assertEquals;
 
+/*
+ * version: 1.0.1
+ */
 public class ClockCreationTest {
 
     @Test

exercises/clock/src/test/java/ClockEqualTest.java

 import org.junit.Ignore;
 import org.junit.Test;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertEquals;
 
+/*
+ * version: 1.0.1
+ */
 public class ClockEqualTest {
 
     @Ignore("Remove to run test")
     @Test
     public void clocksWithSameTimeAreEqual() {
-        assertTrue(new Clock(15, 37).equals(new Clock(15, 37)));
+        assertEquals(new Clock(15, 37), new Clock(15, 37));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void clocksAMinuteApartAreNotEqual() {
-        assertFalse(new Clock(15, 36).equals(new Clock(15, 37)));
+        assertNotEquals(new Clock(15, 36), new Clock(15, 37));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void clocksAnHourApartAreNotEqual() {
-        assertFalse(new Clock(14, 37).equals(new Clock(15, 37)));
+        assertNotEquals(new Clock(14, 37), new Clock(15, 37));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void clocksWithHourOverflow() {
-        assertTrue(new Clock(10, 37).equals(new Clock(34, 37)));
+        assertEquals(new Clock(10, 37), new Clock(34, 37));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void clocksWithHourOverflowBySeveralDays() {
-        assertTrue(new Clock(3, 11).equals(new Clock(99, 11)));
+        assertEquals(new Clock(3, 11), new Clock(99, 11));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void clocksWithNegateHour() {
-        assertTrue(new Clock(22, 40).equals(new Clock(-2, 40)));
+        assertEquals(new Clock(22, 40), new Clock(-2, 40));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void clocksWithNegativeHourThatWraps() {
-        assertTrue(new Clock(17, 3).equals(new Clock(-31, 3)));
+        assertEquals(new Clock(17, 3), new Clock(-31, 3));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void clocksWithNegativeHourThatWrapsMultipleTimes() {
-        assertTrue(new Clock(13, 49).equals(new Clock(-83, 49)));
+        assertEquals(new Clock(13, 49), new Clock(-83, 49));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void clocksWithMinuteOverflow() {
-        assertTrue(new Clock(0, 1).equals(new Clock(0, 1441)));
+        assertEquals(new Clock(0, 1), new Clock(0, 1441));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void clocksWithMinuteOverflowBySeveralDays() {
-        assertTrue(new Clock(2, 2).equals(new Clock(2, 4322)));
+        assertEquals(new Clock(2, 2), new Clock(2, 4322));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void clocksWithNegativeMinutes() {
-        assertTrue(new Clock(2, 40).equals(new Clock(3, -20)));
+        assertEquals(new Clock(2, 40), new Clock(3, -20));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void clocksWithNegativeMinutesThatWraps() {
-        assertTrue(new Clock(4, 10).equals(new Clock(5, -1490)));
+        assertEquals(new Clock(4, 10), new Clock(5, -1490));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void clocksWithNegativeMinutesThatWrapsMultipleTimes() {
-        assertTrue(new Clock(6, 15).equals(new Clock(6, -4305)));
+        assertEquals(new Clock(6, 15), new Clock(6, -4305));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void clocksWithNegativeHoursAndMinutes() {
-        assertTrue(new Clock(7, 32).equals(new Clock(-12, -268)));
+        assertEquals(new Clock(7, 32), new Clock(-12, -268));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void clocksWithNegativeHoursAndMinutesThatWrap() {
-        assertTrue(new Clock(18, 7).equals(new Clock(-54, -11513)));
+        assertEquals(new Clock(18, 7), new Clock(-54, -11513));
     }
+
 }

exercises/collatz-conjecture/build.gradle

+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testCompile "junit:junit:4.12"
+}
+
+test {
+    testLogging {
+        exceptionFormat = 'full'
+        events = ["passed", "failed", "skipped"]
+    }
+}

exercises/collatz-conjecture/src/example/java/CollatzCalculator.java

+class CollatzCalculator {
+
+    int computeStepCount(final int start) {
+        if (start <= 0) throw new IllegalArgumentException("Only natural numbers are allowed");
+
+        if (start == 1) return 0;
+
+        final int next;
+
+        if (start % 2 == 0) {
+            next = start / 2;
+        } else {
+            next = 3 * start + 1;
+        }
+
+        return 1 + computeStepCount(next);
+    }
+
+}

exercises/collatz-conjecture/src/main/java/CollatzCalculator.java

+class CollatzCalculator {
+
+    int computeStepCount(int start) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

exercises/collatz-conjecture/src/test/java/CollatzCalculatorTest.java

+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import static org.junit.Assert.assertEquals;
+
+/*
+ * version: 1.1.0
+ */
+public class CollatzCalculatorTest {
+
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    private CollatzCalculator collatzCalculator;
+
+    @Before
+    public void setUp() {
+        collatzCalculator = new CollatzCalculator();
+    }
+
+    @Test
+    public void testZeroStepsRequiredWhenStartingFrom1() {
+        assertEquals(0, collatzCalculator.computeStepCount(1));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testCorrectNumberOfStepsWhenAllStepsAreDivisions() {
+        assertEquals(4, collatzCalculator.computeStepCount(16));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testCorrectNumberOfStepsWhenBothStepTypesAreNeeded() {
+        assertEquals(9, collatzCalculator.computeStepCount(12));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testAVeryLargeInput() {
+        assertEquals(152, collatzCalculator.computeStepCount(1000000));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testZeroIsConsideredInvalidInput() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Only natural numbers are allowed");
+
+        collatzCalculator.computeStepCount(0);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testNegativeIntegerIsConsideredInvalidInput() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Only natural numbers are allowed");
+
+        collatzCalculator.computeStepCount(-15);
+    }
+
+}

exercises/crypto-square/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/diamond/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/diamond/src/example/java/DiamondPrinter.java

     List<String> printToList(final char chr) {
         final int nRows = 2 * ((int) chr - A_INT) + 1;
 
-        final List<String> topRows = new ArrayList<>();
+        final List<String> result = new ArrayList<>();
 
         // Populate the top rows.
         for (int nRow = 0; nRow < (nRows + 1) / 2; nRow++) {
             final String rightHalfOfRow = reverse(leftHalfOfRow.substring(0, leftHalfOfRow.length() - 1));
             final String fullRow        = leftHalfOfRow + rightHalfOfRow;
 
-            topRows.add(fullRow);
+            result.add(fullRow);
         }
 
         // Populate the bottom rows by 'reflecting' the top rows.
         for (int nRow = (nRows - 1) / 2 - 1; nRow >= 0; nRow--) {
-            topRows.add(topRows.get(nRow));
+            result.add(result.get(nRow));
         }
 
-        return topRows;
+        return result;
     }
 
 }

exercises/diamond/src/main/java/DiamondPrinter.java

-final class DiamondPrinter {
+class DiamondPrinter {
 
 
 

exercises/diamond/src/test/java/DiamondPrinterTest.java

 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertThat;
 
+/*
+ * version: 1.0.0
+ */
 public class DiamondPrinterTest {
+
     private DiamondPrinter diamondPrinter;
-    
+
     @Before
     public void setUp() {
         diamondPrinter = new DiamondPrinter();
     }
-        
+
     @Test
     public void testOneByOneDiamond() {
         List<String> output = diamondPrinter.printToList('A');

exercises/difference-of-squares/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/difference-of-squares/src/main/java/DifferenceOfSquaresCalculator.java

-final class DifferenceOfSquaresCalculator {
-
-    int computeSquareOfSumTo(final int input) {
-        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
-    }
-
-    int computeSumOfSquaresTo(final int input) {
-        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
-    }
-
-    int computeDifferenceOfSquares(final int input) {
-      throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
-    }
-
-}

exercises/etl/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/flatten-array/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/flatten-array/src/main/java/Flattener.java

-final class Flattener {
+class Flattener {
 
 
 

exercises/gigasecond/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/grade-school/build.gradle

   testCompile group: 'org.hamcrest', name: 'hamcrest-library', version: '1.3'
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/hamming/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/hello-world/GETTING_STARTED.md

 left off.  If you haven't reviewed those instructions, do so now.
 
 Need more information?  A **step-by-step tutorial** is available in this directory at TUTORIAL.md or you can read 
-the [HTML version](https://github.com/exercism/xjava/blob/master/exercises/hello-world/TUTORIAL.md).
+the [HTML version](https://github.com/exercism/java/blob/master/exercises/hello-world/TUTORIAL.md).
 
 The following instructions work equally well on Windows, Mac OS X and Linux.
 
 $ gradle test
 ```
 
+To help you focus on one test at a time, [@Ignore](http://junit.sourceforge.net/javadoc/org/junit/Ignore.html)
+annotations have been added to every test but the first one. Any test with an `@Ignore` annotation will be skipped
+when you run the tests.
+
 ## Iterate through the tests
 
 After your first test passes, remove the `@Ignore` from the next test, and iterate on your solution,

exercises/hello-world/TUTORIAL.md

 NOTE: You can also view the HTML version of this file here:
-https://github.com/exercism/xjava/blob/master/exercises/hello-world/TUTORIAL.md
+https://github.com/exercism/java/blob/master/exercises/hello-world/TUTORIAL.md
 
 * [Solving "Hello, World!"](#solving-hello-world)
  * [Reading Gradle output](#reading-gradle-output)
 
 * What went wrong:
 Execution failed for task ':test'.
-> There were failing tests. See the report at: file:///Users/jtigger/projects/exercism/xjava/build/exercism/java/hello-world/build/reports/tests/index.html
+> There were failing tests. See the report at: file:///Users/jtigger/projects/exercism/java/build/exercism/java/hello-world/build/reports/tests/index.html
 
 * Try:
 Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output.
 
 A starting point to jumping in can be found here:
 
-https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md
+https://github.com/exercism/problem-specifications/blob/master/CONTRIBUTING.md
 
 
 ----

exercises/hexadecimal/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/isogram/HINT.md

+If you find that `testWorksWithGermanLetters` fails even though you think you've implemented it correctly,
+this could be because of the [JVM encoding](https://www.ibm.com/support/knowledgecenter/en/ssw_ibm_i_61/rzaha/international.htm). 
+Try setting the `JAVA_TOOL_OPTIONS` environment variable to `-Dfile.encoding=UTF8` to fix this.
+- To set an environment variable on Windows:
+    1. Go to Computer -> Properties -> Advanced System Settings
+    2. Add a new environment variable
+
+- [To set an environment variable on a mac](http://blog.lidalia.org.uk/2011/04/setting-default-java-file-encoding-to.html)
+
+- [To set an environment variable on linux](https://unix.stackexchange.com/questions/151733/where-can-i-set-global-java-options)

exercises/isogram/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/kindergarten-garden/build.gradle

 dependencies {
     testCompile "junit:junit:4.12"
 }
+
 test {
     testLogging {
         exceptionFormat = 'full'

exercises/kindergarten-garden/src/test/java/KindergartenGardenTest.java

 
     @Ignore("Remove to run test")
     @Test
-    public void customStudentGardenFirstStudent() {
+    public void customStudentGardenFirstStudentInAlphabeticalOrder() {
         String[] studentArray = {"Samantha", "Patricia", "Xander", "Roger"};
         String student = "Patricia";
         String plants = "VCRRGVRG\nRVGCCGCV";
 
     @Ignore("Remove to run test")
     @Test
-    public void customStudentGardenSecondStudent() {
+    public void customStudentGardenSecondStudentInAlphabeticalOrder() {
         String[] studentArray = {"Samantha", "Patricia", "Xander", "Roger"};
         String student = "Roger";
         String plants = "VCRRGVRG\nRVGCCGCV";
 
     @Ignore("Remove to run test")
     @Test
-    public void customStudentGardenThirdStudent() {
+    public void customStudentGardenThirdStudentInAlphabeticalOrder() {
         String[] studentArray = {"Samantha", "Patricia", "Xander", "Roger"};
         String student = "Samantha";
         String plants = "VCRRGVRG\nRVGCCGCV";
 
     @Ignore("Remove to run test")
     @Test
-    public void customStudentGardenFourthStudent() {
+    public void customStudentGardenFourthStudentInAlphabeticalOrder() {
         String[] studentArray = {"Samantha", "Patricia", "Xander", "Roger"};
         String student = "Xander";
         String plants = "VCRRGVRG\nRVGCCGCV";

exercises/largest-series-product/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/linked-list/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/luhn/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/luhn/src/main/java/LuhnValidator.java

-final class LuhnValidator {
+class LuhnValidator {
 
     boolean isValid(String candidate) {
         throw new UnsupportedOperationException("Delete this statement and write your own implementation.");

exercises/matrix/build.gradle

 dependencies {
     testCompile "junit:junit:4.12"
 }
+
 test {
     testLogging {
         exceptionFormat = 'full'
         events = ["passed", "failed", "skipped"]
     }
-}
+}

exercises/meetup/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/minesweeper/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/minesweeper/src/main/java/MinesweeperBoard.java

-public final class MinesweeperBoard {
+public class MinesweeperBoard {
 
 
 

exercises/nth-prime/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/ocr-numbers/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/ocr-numbers/src/example/java/OpticalCharacterReader.java

  */
 final class OpticalCharacterReader {
 
-    private static final int ROWS_PER_LINE  = 4;
+    private static final int ROWS_PER_LINE = 4;
 
     private static final int COLS_PER_SSD = 3;
 
                     "Number of input rows must be a positive multiple of " + ROWS_PER_LINE);
         }
 
-        final int inputColumnCount = input.get(0).length();
+        final int inputColCount = input.get(0).length();
 
-        if (inputColumnCount == 0 || inputColumnCount % 3 != 0) {
+        if (inputColCount == 0 || inputColCount % 3 != 0) {
             throw new IllegalArgumentException(
                     "Number of input columns must be a positive multiple of " + COLS_PER_SSD);
         }

exercises/ocr-numbers/src/main/java/OpticalCharacterReader.java

-final class OpticalCharacterReader {
+class OpticalCharacterReader {
 
 
 

exercises/octal/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/pangram/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/pascals-triangle/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/perfect-numbers/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/perfect-numbers/src/main/java/NaturalNumber.java

-final class NaturalNumber {
+class NaturalNumber {
 
 
 

exercises/perfect-numbers/src/test/java/NaturalNumberTest.java

 
 /*
  * version: 1.0.0
- * https://github.com/exercism/x-common/blob/19d0c7714ce664a1ad762af624c17f8e269fa8b2/exercises/perfect-numbers/canonical-data.json
  */
 public class NaturalNumberTest {
 

exercises/phone-number/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/pig-latin/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/pythagorean-triplet/src/test/java/PythagoreanTripletTest.java

 
     @Test
     public void shouldCalculateSum() {
-        PythagoreanTriplet sut = new PythagoreanTriplet(3, 4, 5);
+        PythagoreanTriplet triplet = new PythagoreanTriplet(3, 4, 5);
         final int expected = 12;
-        final int actual = sut.calculateSum();
+        final int actual = triplet.calculateSum();
         assertEquals(expected, actual);
     }
 
     @Test
     @Ignore("Remove to run test")
     public void shouldCalculateProduct() {
-        PythagoreanTriplet sut = new PythagoreanTriplet(3, 4, 5);
+        PythagoreanTriplet triplet = new PythagoreanTriplet(3, 4, 5);
         final long expected = 60l;
-        final long actual = sut.calculateProduct();
+        final long actual = triplet.calculateProduct();
         assertEquals(expected, actual);
     }
 
     @Test
     @Ignore("Remove to run test")
     public void testIsPythagoreanOK() {
-        PythagoreanTriplet sut = new PythagoreanTriplet(3, 4, 5);
-        assertTrue(sut.isPythagorean());
+        PythagoreanTriplet triplet = new PythagoreanTriplet(3, 4, 5);
+        assertTrue(triplet.isPythagorean());
     }
 
     @Test
     @Ignore("Remove to run test")
     public void testIsPythagoreanFail() {
-        PythagoreanTriplet sut = new PythagoreanTriplet(5, 6, 7);
-        assertFalse(sut.isPythagorean());
+        PythagoreanTriplet triplet = new PythagoreanTriplet(5, 6, 7);
+        assertFalse(triplet.isPythagorean());
     }
 
     @Test

exercises/queen-attack/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/queen-attack/src/main/java/BoardCoordinate.java

-public final class BoardCoordinate {
+public class BoardCoordinate {
 
 
 

exercises/queen-attack/src/main/java/QueenAttackCalculator.java

-public final class QueenAttackCalculator {
+public class QueenAttackCalculator {
 
 
 

exercises/raindrops/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/rectangles/build.gradle

 dependencies {
   testCompile "junit:junit:4.12"
 }
+
 test {
   testLogging {
     exceptionFormat = 'full'

exercises/rectangles/src/main/java/RectangleCounter.java

-final class RectangleCounter {
+class RectangleCounter {