Merge branch 'master' into two-fer

.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

CONTRIBUTING.md

+Hi! Thanks for contributing to the Exercism Java track!
+
+Before opening your pull request, please review the track policies linked below and make sure your changes comply with them all. This helps us focus our review time on the more important aspects of your changes.
+
+- [Prefer instance methods](https://github.com/exercism/java/blob/master/POLICIES.md#prefer-instance-methods)
+- [Starter implementations](https://github.com/exercism/java/blob/master/POLICIES.md#starter-implementations)
+- [Ignore noninitial tests](https://github.com/exercism/java/blob/master/POLICIES.md#ignore-noninitial-tests)
+- [Multiple file submissions](https://github.com/exercism/java/blob/master/POLICIES.md#multiple-file-submissions)

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

_template/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"]
+  }
+}

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": "two-fer",
     {
       "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": [
+
+      ]
+    },
+    {
+      "slug": "transpose",
+      "difficulty": 6,
+      "topics": [
+
+      ]
+    },
+    {
+      "slug": "food-chain",
+      "difficulty": 6,
       "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": [
+      
+      ]
     }
   ],
   "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/food-chain/src/example/java/FoodChain.java

+import java.util.stream.IntStream;
+
+public class FoodChain {
+
+    private static final String[] ANIMALS = {
+        "fly",
+        "spider",
+        "bird",
+        "cat",
+        "dog",
+        "goat",
+        "cow"
+    };
+
+    private static final String[] FOLLOWUPS = {
+        "It wriggled and jiggled and tickled inside her.",
+        "How absurd to swallow a bird!",
+        "Imagine that, to swallow a cat!",
+        "What a hog, to swallow a dog!",
+        "Just opened her throat and swallowed a goat!",
+        "I don't know how she swallowed a cow!"
+    };
+
+    public String verse(int verse) {
+        return verseBeginning(verse) + verseMiddle(verse) + verseEnding(verse);
+    }
+
+    public String verses(int startVerse, int endVerse) {
+
+        String[] verses = new String[endVerse - startVerse + 1];
+
+        for (int i = 0; i <= endVerse - startVerse; i++) {
+            verses[i] = verse(i + 1);
+        }
+
+        return String.join("\n\n", verses);
+    }
+
+    private String verseBeginning(int verse) {
+
+        if (verse == 1) {
+            return "I know an old lady who swallowed a fly.\n";
+        }
+
+        if (verse == 8) {
+            return "I know an old lady who swallowed a horse.\n";
+        }
+
+        return "I know an old lady who swallowed a " + ANIMALS[verse - 1] + ".\n" + FOLLOWUPS[verse - 2] + "\n";
+    }
+
+    private String verseMiddle(int verse) {
+
+        if (verse == 1 || verse == 8) {
+            return "";
+        }
+
+        String[] lines = new String[verse - 1];
+
+        for (int i = verse - 1; i >= 1; i--) {
+            lines[lines.length - i] = "She swallowed the " +
+                    ANIMALS[i] + " to catch the " + ANIMALS[i - 1] +
+                    (i == 2 ? " that wriggled and jiggled and tickled inside her." : ".");
+        }
+
+        return String.join("\n", lines) + "\n";
+    }
+
+    private String verseEnding(int verse) {
+
+        if (verse == 8) {
+            return "She's dead, of course!";
+        }
+
+        return "I don't know why she swallowed the fly. Perhaps she'll die.";
+    }
+}

exercises/food-chain/src/test/java/FoodChainTest.java

+import org.junit.Before;
+import org.junit.Test;
+import org.junit.Ignore;
+
+import static org.junit.Assert.assertEquals;
+
+public class FoodChainTest {
+    private FoodChain foodChain;
+
+    @Before
+    public void setup() {
+        foodChain = new FoodChain();
+    }
+
+    @Test
+    public void fly() {
+        int verse = 1;
+        String expected = "I know an old lady who swallowed a fly.\n" +
+                          "I don't know why she swallowed the fly. Perhaps she'll die.";
+
+        assertEquals(expected, foodChain.verse(verse));
+    }
+
+    @Test
+    @Ignore("Remove to run test.")
+    public void spider() {
+        int verse = 2;
+        String expected = "I know an old lady who swallowed a spider.\n" +
+                          "It wriggled and jiggled and tickled inside her.\n" +
+                          "She swallowed the spider to catch the fly.\n" +
+                          "I don't know why she swallowed the fly. Perhaps she'll die.";
+
+        assertEquals(expected, foodChain.verse(verse));
+    }
+
+    @Test
+    @Ignore("Remove to run test.")
+    public void bird() {
+        int verse = 3;
+        String expected = "I know an old lady who swallowed a bird.\n" +
+                          "How absurd to swallow a bird!\n" +
+                          "She swallowed the bird to catch the spider that wriggled and jiggled and tickled inside her.\n" +
+                          "She swallowed the spider to catch the fly.\n" +
+                          "I don't know why she swallowed the fly. Perhaps she'll die.";
+
+        assertEquals(expected, foodChain.verse(verse));
+    }
+
+    @Test
+    @Ignore("Remove to run test.")
+    public void cat() {
+        int verse = 4;
+        String expected = "I know an old lady who swallowed a cat.\n" +
+                          "Imagine that, to swallow a cat!\n" +
+                          "She swallowed the cat to catch the bird.\n" +
+                          "She swallowed the bird to catch the spider that wriggled and jiggled and tickled inside her.\n" +
+                          "She swallowed the spider to catch the fly.\n" +
+                          "I don't know why she swallowed the fly. Perhaps she'll die.";
+
+        assertEquals(expected, foodChain.verse(verse));
+    }
+
+
+    @Test
+    @Ignore("Remove to run test.")
+    public void dog() {
+        int verse = 5;
+        String expected = "I know an old lady who swallowed a dog.\n" +
+                          "What a hog, to swallow a dog!\n" +
+                          "She swallowed the dog to catch the cat.\n" +
+                          "She swallowed the cat to catch the bird.\n" +
+                          "She swallowed the bird to catch the spider that wriggled and jiggled and tickled inside her.\n" +
+                          "She swallowed the spider to catch the fly.\n" +
+                          "I don't know why she swallowed the fly. Perhaps she'll die.";
+
+        assertEquals(expected, foodChain.verse(verse));
+    }
+
+    @Test
+    @Ignore("Remove to run test.")
+    public void goat() {
+        int verse = 6;
+        String expected = "I know an old lady who swallowed a goat.\n" +
+                          "Just opened her throat and swallowed a goat!\n" +
+                          "She swallowed the goat to catch the dog.\n" +
+                          "She swallowed the dog to catch the cat.\n" +
+                          "She swallowed the cat to catch the bird.\n" +
+                          "She swallowed the bird to catch the spider that wriggled and jiggled and tickled inside her.\n" +
+                          "She swallowed the spider to catch the fly.\n" +
+                          "I don't know why she swallowed the fly. Perhaps she'll die.";
+
+        assertEquals(expected, foodChain.verse(verse));
+    }
+
+    @Test
+    @Ignore("Remove to run test.")
+    public void cow() {
+        int verse = 7;
+        String expected = "I know an old lady who swallowed a cow.\n" +
+                          "I don't know how she swallowed a cow!\n" +
+                          "She swallowed the cow to catch the goat.\n" +
+                          "She swallowed the goat to catch the dog.\n" +
+                          "She swallowed the dog to catch the cat.\n" +
+                          "She swallowed the cat to catch the bird.\n" +
+                          "She swallowed the bird to catch the spider that wriggled and jiggled and tickled inside her.\n" +
+                          "She swallowed the spider to catch the fly.\n" +
+                          "I don't know why she swallowed the fly. Perhaps she'll die.";
+
+        assertEquals(expected, foodChain.verse(verse));
+    }
+
+    @Test
+    @Ignore("Remove to run test.")
+    public void horse() {
+        int verse = 8;
+        String expected = "I know an old lady who swallowed a horse.\n" +
+                          "She's dead, of course!";
+
+        assertEquals(expected, foodChain.verse(verse));
+    }
+
+
+    @Test
+    @Ignore("Remove to run test.")
+    public void multipleVerses() {
+        int startVerse = 1;
+        int endVerse = 3;
+        String expected = "I know an old lady who swallowed a fly.\n" +
+                          "I don't know why she swallowed the fly. Perhaps she'll die.\n" +
+                          "\n" +
+                          "I know an old lady who swallowed a spider.\n" +
+                          "It wriggled and jiggled and tickled inside her.\n" +
+                          "She swallowed the spider to catch the fly.\n" +
+                          "I don't know why she swallowed the fly. Perhaps she'll die.\n" +
+                          "\n" +
+                          "I know an old lady who swallowed a bird.\n" +
+                          "How absurd to swallow a bird!\n" +
+                          "She swallowed the bird to catch the spider that wriggled and jiggled and tickled inside her.\n" +
+                          "She swallowed the spider to catch the fly.\n" +
+                          "I don't know why she swallowed the fly. Perhaps she'll die.";
+
+        assertEquals(expected, foodChain.verses(startVerse, endVerse));
+    }
+
+
+    @Test
+    @Ignore("Remove to run test.")
+    public void wholeSong() {
+        int startVerse = 1;
+        int endVerse = 8;
+        String expected = "I know an old lady who swallowed a fly.\n" +
+                          "I don't know why she swallowed the fly. Perhaps she'll die.\n" +
+                          "\n" +
+                          "I know an old lady who swallowed a spider.\n" +
+                          "It wriggled and jiggled and tickled inside her.\n" +
+                          "She swallowed the spider to catch the fly.\n" +
+                          "I don't know why she swallowed the fly. Perhaps she'll die.\n" +
+                          "\n" +
+                          "I know an old lady who swallowed a bird.\n" +
+                          "How absurd to swallow a bird!\n" +
+                          "She swallowed the bird to catch the spider that wriggled and jiggled and tickled inside her.\n" +
+                          "She swallowed the spider to catch the fly.\n" +
+                          "I don't know why she swallowed the fly. Perhaps she'll die.\n" +
+                          "\n" +
+                          "I know an old lady who swallowed a cat.\n" +
+                          "Imagine that, to swallow a cat!\n" +
+                          "She swallowed the cat to catch the bird.\n" +
+                          "She swallowed the bird to catch the spider that wriggled and jiggled and tickled inside her.\n" +
+                          "She swallowed the spider to catch the fly.\n" +
+                          "I don't know why she swallowed the fly. Perhaps she'll die.\n" +
+                          "\n" +
+                          "I know an old lady who swallowed a dog.\n" +
+                          "What a hog, to swallow a dog!\n" +
+                          "She swallowed the dog to catch the cat.\n" +
+                          "She swallowed the cat to catch the bird.\n" +
+                          "She swallowed the bird to catch the spider that wriggled and jiggled and tickled inside her.\n" +
+                          "She swallowed the spider to catch the fly.\n" +
+                          "I don't know why she swallowed the fly. Perhaps she'll die.\n" +
+                          "\n" +
+                          "I know an old lady who swallowed a goat.\n" +
+                          "Just opened her throat and swallowed a goat!\n" +
+                          "She swallowed the goat to catch the dog.\n" +
+                          "She swallowed the dog to catch the cat.\n" +
+                          "She swallowed the cat to catch the bird.\n" +
+                          "She swallowed the bird to catch the spider that wriggled and jiggled and tickled inside her.\n" +
+                          "She swallowed the spider to catch the fly.\n" +
+                          "I don't know why she swallowed the fly. Perhaps she'll die.\n" +
+                          "\n" +
+                          "I know an old lady who swallowed a cow.\n" +
+                          "I don't know how she swallowed a cow!\n" +
+                          "She swallowed the cow to catch the goat.\n" +
+                          "She swallowed the goat to catch the dog.\n" +
+                          "She swallowed the dog to catch the cat.\n" +
+                          "She swallowed the cat to catch the bird.\n" +
+                          "She swallowed the bird to catch the spider that wriggled and jiggled and tickled inside her.\n" +
+                          "She swallowed the spider to catch the fly.\n" +
+                          "I don't know why she swallowed the fly. Perhaps she'll die.\n" +
+                          "\n" +
+                          "I know an old lady who swallowed a horse.\n" +
+                          "She's dead, of course!";
+
+        assertEquals(expected, foodChain.verses(startVerse, endVerse));
+    }
+}

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, iterate on your solution, testing after each change.

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)
 
 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'