Merge branch 'master' into poker

.gitattributes

+# Autodetect text files
+* text=auto
+
+# Force the following filetypes to have unix eols, so Windows does not break them
+*.* text eol=lf
+
+# Force images/fonts to be handled as binaries
+*.jpg binary
+*.jpeg binary
+*.png binary

.github/PULL_REQUEST_TEMPLATE.md

+<!-- Your content goes here: -->
+
+
+
+<!-- DO NOT EDIT BELOW THIS LINE! -->
+---
+
+Reviewer Resources:
+
+[Track Policies](https://github.com/exercism/xjava/blob/master/POLICIES.md#event-checklist)

.gitignore

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

.travis.yml

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

LICENSE

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

POLICIES.md

+# Track Policies
+
+This document:
+
+- describes all current track-wide policies; and
+- lists all policies that should be reviewed in response to any given track event.
+
+Maintainers should refer to this document each time they review a pull request.
+
+Our policies are not set-in-stone. They represent directions chosen at a point in time with the information/context available at that time. We actively encourage contributors to review and critique them. If you have read through the references that informed an existing policy and still feel it should be improved or removed, please comment and describe:
+
+1. your alternative perspective;
+2. your proposed changes; and
+3. how your proposal balances your own perspective with those already raised during prior discussions.
+
+## Event Checklist
+
+| Track Event | Policies to review |
+|:------------|:-----------------|
+| Exercise added | [Prefer instance methods](#prefer-instance-methods); [Starter implementations](#starter-implementations); [Ignore noninitial tests](#ignore-noninitial-tests) |
+| Exercise updated | [Ignore noninitial tests](#ignore-noninitial-tests); [Multiple file submissions](#multiple-file-submissions) |
+| Track order changed | [Starter implementations](#starter-implementations); [Multiple file submissions](#multiple-file-submissions) |
+| New issue observed in track | [Good first patches](#good-first-patches) |
+| "Good first patch" issue completed | [Good first patches](#good-first-patches) |
+| Installing Java instructions updated | [Simple onboarding](#simple-onboarding) |
+
+## Policy Descriptions
+
+### Prefer instance methods
+
+> 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/java/issues/177#issuecomment-261291741)]
+
+### Starter implementations
+
+> - Exercises 1-10: provide stubs for all required constructors and methods. Stubs should include the following body:
+    `throw new UnsupportedOperationException("Delete this statement and write your own implementation.");`
+> - Exercises 11-20: provide stubs for all constructors and methods required by the first test; comment-out the bodies of any tests that require non-stubbed constructors or methods. Stubs should include the following body:
+    `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/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/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/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/java/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+patch%22).
+
+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/java/issues/395#issue-215734887)]

README.md

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

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

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

bin/fetch-configlet

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

bin/journey-test.sh

 #!/usr/bin/env bash
 
+# This script is shared between the Java and Kotlin tracks.  If you make an update to this script on
+# one track, please create a companion PR to merge it in to the other.  Thank you!
+TRACK=java
+TRACK_REPO="$TRACK"
+TRACK_SRC_EXT="java"
+
 on_exit() {
   echo ">>> on_exit()"
   if [[ "$xapi_pid" != "" ]] ; then
 
   if [[ "`which $binary`" == "" ]]; then
     echo "${binary} not found; it is required to perform this test."
-    echo -e "Have you completed the setup instructions at https://github.com/exercism/xjava ?\n"
+    echo -e "Have you completed the setup instructions at https://github.com/exercism/${TRACK_REPO} ?\n"
     echo "PATH=${PATH}"
     echo "aborting."
     exit 1
   if [[ "${expected_ruby_ver}" != "" && "${current_ruby_ver}" != "${expected_ruby_ver}" ]]; then
     echo "${ruby_app_home} requires Ruby ${expected_ruby_ver}; current Ruby version is ${current_ruby_ver}."
     echo -e "Ruby used: `which ruby`.\n"
-    echo -e "Have you completed the setup instructions at https://github.com/exercism/xjava ?\n"
+    echo -e "Have you completed the setup instructions at https://github.com/exercism/${TRACK_REPO} ?\n"
     echo "PATH=${PATH}"
     echo "aborting."
     exit 1
     rm -rf "${build_path}"
   fi
   cd exercises
-  gradle clean
+  "$EXECPATH"/gradlew clean
   cd ..
   echo "<<< clean()"
 }
   local xapi_home="$2"
   echo ">>> make_local_trackler(trackler=\"${trackler}\", xapi_home=\"${xapi_home}\")"
 
-  local xjava=$( pwd )
+  local track_root=$( pwd )
   pushd ${trackler}
+
+  # Get the version of Trackler x-api is currently using
+  local version=$( grep -m 1 'trackler' ${xapi_home}/Gemfile.lock | sed 's/.*(//' | sed 's/)//' )
+
+  git checkout v${version}
   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
-
-  # Set the version to that expected by x-api
-  version=$( grep -m 1 'trackler' ${xapi_home}/Gemfile.lock | sed 's/.*(//' | sed 's/)//' )
-  echo "module Trackler VERSION = \"${version}\" end" > lib/trackler/version.rb
+  # 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
+    "$EXECPATH"/gradlew compileTestJava
     # Ensure we run all the tests (as delivered, all but the first is @Ignore'd)
-    for testfile in `find . -name "*Test.java"`; do
-      sed 's/@Ignore//' ${testfile} > "${tempfile}" && mv "${tempfile}" "${testfile}"
+    for testfile in `find . -name "*Test.${TRACK_SRC_EXT}"`; do
+      # Strip @Ignore annotations to ensure we run the tests (as delivered, all but the first is @Ignore'd).
+      # Note that unit-test.sh also strips @Ignore annotations via the Gradle task copyTestsFilteringIgnores.
+      # The stripping implementations here and in copyTestsFilteringIgnores should be kept consistent.
+      sed 's/@Ignore\(\(.*\)\)\{0,1\}//' ${testfile} > "${tempfile}" && mv "${tempfile}" "${testfile}"
     done
-    gradle test
+    "$EXECPATH"/gradlew test
     popd
 
     current_exercise_number=$((current_exercise_number + 1))
   # all functions assume current working directory is repository root.
   cd "${SCRIPTPATH}/.."
 
-  local xjava=$( pwd )
+  local track_root=$( pwd )
   local build_dir="build"
-  local build_path="${xjava}/${build_dir}"
+  local build_path="${track_root}/${build_dir}"
 
   local xapi_home="${build_path}/x-api"
   local trackler_home="${build_path}/trackler"
   local xapi_port=9292
 
   # fail fast if required binaries are not installed.
-  assert_installed "gradle"
   assert_installed "jq"
 
   clean "${build_dir}"
 
-  # Make a version of trackler that includes the source from this repo.
+  # Make a local version of trackler that includes the source from this repo.
   git_clone "x-api" "${xapi_home}"
   git_clone "trackler" "${trackler_home}"
   assert_ruby_installed "${trackler_home}"

bin/unit-tests.sh

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

config.json

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

docs/INSTALLATION.md

 * [Linux](#linux)
 
 ... or ...
-* if you prefer to not use a package maanger, you can [install manually](#install-manually).
+* if you prefer to not use a package manager, you can [install manually](#install-manually).
 
 Optionally, you can also use a [Java IDE](#java-ides).
 
    ...
    ```
 
-We recommend closing the administrative command prompt and opening a new command prompt -- you do not require administrator priviledges to practice Exercism exercises.
+We recommend closing the administrative command prompt and opening a new command prompt -- you do not require administrator privileges to practice Exercism exercises.
 
 You now are ready to get started with the Java track of Exercism!
 

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/accumulate/src/test/java/AccumulateTest.java

         assertEquals(expectedOutput, Accumulate.accumulate(input, x -> x * x));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void accumulateSquares() {
         List<Integer> input = Arrays.asList(1, 2, 3);
         assertEquals(expectedOutput, Accumulate.accumulate(input, x -> x * x));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void accumulateUpperCases() {
         List<String> input = Arrays.asList("hello", "world");
         assertEquals(expectedOutput, Accumulate.accumulate(input, x -> x.toUpperCase()));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void accumulateReversedStrings() {
         List<String> input = Arrays.asList("the quick brown fox etc".split(" "));
         return new StringBuilder(input).reverse().toString();
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void accumulateWithinAccumulate() {
         List<String> input1 = Arrays.asList("a", "b", "c");

exercises/acronym/build.gradle

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

exercises/acronym/src/example/java/Acronym.java

 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-public class Acronym {
-    public static String generate(String phrase){
+final class Acronym {
+
+    private final String acronym;
+
+    Acronym(String phrase) {
+        acronym = generateAcronym(phrase);
+    }
+
+    String get() {
+        return acronym;
+    }
+
+    private String generateAcronym(String phrase){
         final Pattern BREAK_WORDS = Pattern.compile("[A-Z]+[a-z]*|[a-z]+");
         final Matcher matcher = BREAK_WORDS.matcher(phrase);
         final StringBuilder b = new StringBuilder();
         }
         return b.toString().toUpperCase();
     }
-}
+
+}

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

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

exercises/acronym/src/test/java/AcronymTest.java

 
 import static org.junit.Assert.assertEquals;
 
+/*
+ * version: 1.1.0
+ */
 public class AcronymTest {
 
-
     @Test
     public void fromTitleCasedPhrases() {
         final String phrase = "Portable Network Graphics";
         final String expected = "PNG";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void fromOtherTitleCasedPhrases() {
         final String phrase = "Ruby on Rails";
         final String expected = "ROR";
-        assertEquals(expected, Acronym.generate(phrase));
-    }
-
-    @Ignore
-    @Test
-    public void fromInconsistentlyCasedPhrases() {
-        final String phrase = "HyperText Markup Language";
-        final String expected = "HTML";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void fromPhrasesWithPunctuation() {
         final String phrase = "First In, First Out";
         final String expected = "FIFO";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void fromOtherPhrasesWithPunctuation() {
         final String phrase = "PHP: Hypertext Preprocessor";
         final String expected = "PHP";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void fromPhrasesWithNonAcronymAllCapsWord() {
         final String phrase = "GNU Image Manipulation Program";
         final String expected = "GIMP";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void fromPhrasesWithPunctuationAndSentenceCasing() {
         final String phrase = "Complementary metal-oxide semiconductor";
         final String expected = "CMOS";
-        assertEquals(expected, Acronym.generate(phrase));
-    }
-
-    @Ignore
-    @Test
-    public void fromPhraseWithSingleLetterWord() {
-        final String phrase = "Cat in a Hat";
-        final String expected = "CIAH";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
 }

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;
 
-public final class BaseConverterTest {
+/*
+ * version: 1.1.0
+ */
+public class BaseConverterTest {
 
     /*
      * See https://github.com/junit-team/junit4/wiki/Rules for information on JUnit Rules in general and
                 actualDigits);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testBinaryToSingleDecimal() {
         final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1});
                 actualDigits);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSingleDecimalToBinary() {
         final BaseConverter baseConverter = new BaseConverter(10, new int[]{5});
                 actualDigits);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testBinaryToMultipleDecimal() {
         final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
                 actualDigits);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testDecimalToBinary() {
         final BaseConverter baseConverter = new BaseConverter(10, new int[]{4, 2});
                 actualDigits);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTrinaryToHexadecimal() {
         final BaseConverter baseConverter = new BaseConverter(3, new int[]{1, 1, 2, 0});
                 actualDigits);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testHexadecimalToTrinary() {
         final BaseConverter baseConverter = new BaseConverter(16, new int[]{2, 10});
                 actualDigits);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void test15BitInteger() {
         final BaseConverter baseConverter = new BaseConverter(97, new int[]{3, 46, 60});
                 actualDigits);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testEmptyDigits() {
         expectedException.expect(IllegalArgumentException.class);
         new BaseConverter(2, new int[]{});
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSingleZero() {
         final BaseConverter baseConverter = new BaseConverter(10, new int[]{0});
                 actualDigits);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testMultipleZeros() {
         expectedException.expect(IllegalArgumentException.class);
         new BaseConverter(10, new int[]{0, 0, 0});
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLeadingZeros() {
         expectedException.expect(IllegalArgumentException.class);
         new BaseConverter(7, new int[]{0, 6, 0});
     }
 
-    @Ignore
+    @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
+    @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
+    @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
+    @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
+    @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
+    @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
+    @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
+    @Ignore("Remove to run test")
     @Test
     public void testSecondBaseIsNegative() {
         final BaseConverter baseConverter = new BaseConverter(2, new int[]{1});

exercises/allergies/build.gradle

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

exercises/allergies/src/test/java/AllergiesTest.java

         assertEquals(false, allergies.isAllergicTo(Allergen.CATS));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void allergicToEggs() {
         Allergies allergies = new Allergies(1);
         assertEquals(true, allergies.isAllergicTo(Allergen.EGGS));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void allergicToPeanuts() {
         Allergies allergies = new Allergies(2);
         assertEquals(true, allergies.isAllergicTo(Allergen.PEANUTS));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void allergicToShellfish() {
         Allergies allergies = new Allergies(4);
         assertEquals(true, allergies.isAllergicTo(Allergen.SHELLFISH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void allergicToStrawberries() {
         Allergies allergies = new Allergies(8);
         assertEquals(true, allergies.isAllergicTo(Allergen.STRAWBERRIES));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void allergicToTomatoes() {
         Allergies allergies = new Allergies(16);
         assertEquals(true, allergies.isAllergicTo(Allergen.TOMATOES));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void allergicToChocolate() {
         Allergies allergies = new Allergies(32);
         assertEquals(true, allergies.isAllergicTo(Allergen.CHOCOLATE));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void allergicToPollen() {
         Allergies allergies = new Allergies(64);
         assertEquals(true, allergies.isAllergicTo(Allergen.POLLEN));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void allergicToCats() {
         Allergies allergies = new Allergies(128);
         assertEquals(true, allergies.isAllergicTo(Allergen.CATS));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void isAllergicToEggsInAdditionToOtherStuff() {
         Allergies allergies = new Allergies(5);
         assertEquals(false, allergies.isAllergicTo(Allergen.STRAWBERRIES));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void noAllergies() {
         Allergies allergies = new Allergies(0);
         assertEquals(0, allergies.getList().size());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void isAllergicToJustEggs() {
         Allergies allergies = new Allergies(1);
         assertEquals(expectedAllergens, allergies.getList());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void isAllergicToJustPeanuts() {
         Allergies allergies = new Allergies(2);
         assertEquals(expectedAllergens, allergies.getList());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void isAllergicToJustStrawberries() {
         Allergies allergies = new Allergies(8);
         assertEquals(expectedAllergens, allergies.getList());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void isAllergicToEggsAndPeanuts() {
         Allergies allergies = new Allergies(3);
         assertEquals(expectedAllergens, allergies.getList());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void isAllergicToEggsAndShellfish() {
         Allergies allergies = new Allergies(5);
         assertEquals(expectedAllergens, allergies.getList());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void isAllergicToLotsOfStuff() {
         Allergies allergies = new Allergies(248);
         assertEquals(expectedAllergens, allergies.getList());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void isAllergicToEverything() {
         Allergies allergies = new Allergies(255);
         assertEquals(expectedAllergens, allergies.getList());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void ignoreNonAllergenScoreParts() {
         Allergies allergies = new Allergies(509);

exercises/anagram/build.gradle

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

exercises/anagram/src/test/java/AnagramTest.java

         assertTrue(detector.match(Arrays.asList("hello", "world", "zombies", "pants")).isEmpty());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testDetectSimpleAnagram() {
         Anagram detector = new Anagram("ant");
         assertThat(anagram.size(), is(1));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testDetectLongerAnagram() {
         Anagram detector = new Anagram("listen");
         assertThat(anagrams, hasItem("inlets"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testDetectMultipleAnagrams() {
         Anagram detector = new Anagram("master");
         assertThat(anagrams, allOf(hasItem("maters"), hasItem("stream")));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testDetectMultipleAnagramsForLongerWord() {
         Anagram detector = new Anagram("allergy");
         assertThat(anagrams, allOf(hasItem("gallery"), hasItem("largely"), hasItem("regally")));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testDoesNotConfuseDifferentDuplicates() {
         Anagram detector = new Anagram("galea");
         assertTrue(detector.match(Arrays.asList("eagle")).isEmpty());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testIdenticalWordIsNotAnagram() {
         Anagram detector = new Anagram("corn");
         assertThat(anagrams.size(), is(1));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testIdenticalWordRepeatedIsNotAnagram() {
         Anagram detector = new Anagram("go");
         assertTrue(detector.match(Arrays.asList("go Go GO")).isEmpty());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCapitalWordIsNotOwnAnagram() {
         Anagram detector = new Anagram("BANANA");
         assertTrue(detector.match(Arrays.asList("Banana")).isEmpty());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testEliminateAnagramsWithSameChecksum() {
         Anagram detector = new Anagram("mass");
         assertTrue(detector.match(Arrays.asList("last")).isEmpty());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testEliminateAnagramSubsets() {
         Anagram detector = new Anagram("good");
         assertTrue(detector.match(Arrays.asList("dog", "goody")).isEmpty());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCaseInsensitiveWhenSubjectStartsWithUpperCaseLetter() {
         Anagram detector = new Anagram("Orchestra");
         assertThat(anagrams, hasItem("carthorse"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCaseInsensitiveWhenAnagramStartsWithUpperCaseLetter() {
         Anagram detector = new Anagram("orchestra");
         assertThat(anagrams, hasItem("Carthorse"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCaseInsensitiveWhenBothAnagramAndSubjectStartWithUpperCaseLetter() {
         Anagram detector = new Anagram("Orchestra");
         assertThat(anagrams, hasItem("Carthorse"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testWordIsNotItsOwnAnagram() {
         Anagram detector = new Anagram("banana");
         assertTrue(detector.match(Arrays.asList("Banana")).isEmpty());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testAnagramMustUseAllLettersExactlyOnce() {
         Anagram detector = new Anagram("tapper");

exercises/atbash-cipher/build.gradle

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

exercises/atbash-cipher/src/example/java/Atbash.java

     private static final String PLAIN = "abcdefghijklmnopqrstuvwxyz";
     private static final String CIPHER = "zyxwvutsrqponmlkjihgfedcba";
 
-    public static String encode(String input) {
+    public String encode(String input) {
         String encoded = stripInvalidCharacters(input).toLowerCase();
         String cyphered = "";
 
         return splitIntoFiveLetterWords(cyphered);
     }
 
-    public static String decode(String input) {
+    public String decode(String input) {
         String encoded = stripInvalidCharacters(input).toLowerCase();
         String deciphered = "";
 
         return deciphered;
     }
 
-    private static String stripInvalidCharacters(String input) {
+    private String stripInvalidCharacters(String input) {
         String filteredValue = "";
 
         for (char c : input.toCharArray()) {
         return filteredValue;
     }
 
-    private static char applyCipher(char input) {
+    private char applyCipher(char input) {
         int idx = PLAIN.indexOf(input);
 
         return idx >= 0 ? CIPHER.toCharArray()[idx] : input;
     }
 
-    private static String splitIntoFiveLetterWords(String value) {
+    private String splitIntoFiveLetterWords(String value) {
         List<String> words = new ArrayList<>();
 
         for (int i = 0; i < value.length(); i += GROUP_SIZE) {

exercises/atbash-cipher/src/test/java/AtbashTest.java

-import org.junit.Test;
 import org.junit.Ignore;
+import org.junit.Test;
 import org.junit.experimental.runners.Enclosed;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
         @Parameters(name = "{index}: expected plaintext \"{0}\" to encode to ciphertext \"{1}\".")
         public static Collection<Object[]> data() {
-            return Arrays.asList(new Object[][] {
-                    { "no", "ml" },
-                    { "yes", "bvh" },
-                    { "OMG", "lnt" },
-                    { "mindblowingly", "nrmwy oldrm tob" },
-                    { "Testing, 1 2 3, testing.", "gvhgr mt123 gvhgr mt" },
-                    { "Truth is fiction.", "gifgs rhurx grlm" },
-                    { "The quick brown fox jumps over the lazy dog.", "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt" }
+            return Arrays.asList(new Object[][]{
+                    {"no", "ml"},
+                    {"yes", "bvh"},
+                    {"OMG", "lnt"},
+                    {"mindblowingly", "nrmwy oldrm tob"},
+                    {"Testing, 1 2 3, testing.", "gvhgr mt123 gvhgr mt"},
+                    {"Truth is fiction.", "gifgs rhurx grlm"},
+                    {"The quick brown fox jumps over the lazy dog.", "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"}
             });
         }
 
         }
 
 
-    @Test
+        @Test
         public void test() {
-            assertEquals(ciphertext, Atbash.encode(plaintext));
+            assertEquals(ciphertext, new Atbash().encode(plaintext));
         }
     }
 
 
         @Parameters(name = "{index}: expected ciphertext \"{0}\" to decode to plaintext \"{1}\".")
         public static Collection<Object[]> data() {
-            return Arrays.asList(new Object[][] {
-                    { "vcvix rhn", "exercism" },
-                    { "zmlyh gzxov rhlug vmzhg vkkrm thglm v", "anobstacleisoftenasteppingstone" },
-                    { "gvhgr mt123 gvhgr mt", "testing123testing" },
-                    { "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt", "thequickbrownfoxjumpsoverthelazydog" }
+            return Arrays.asList(new Object[][]{
+                    {"vcvix rhn", "exercism"},
+                    {"zmlyh gzxov rhlug vmzhg vkkrm thglm v", "anobstacleisoftenasteppingstone"},
+                    {"gvhgr mt123 gvhgr mt", "testing123testing"},
+                    {"gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt", "thequickbrownfoxjumpsoverthelazydog"}
             });
         }
 
             this.plaintext = plaintext;
         }
 
-        @Ignore
-    @Test
+        @Ignore("Remove to run tests")
+        @Test
         public void test() {
-            assertEquals(plaintext, Atbash.decode(ciphertext));
+            assertEquals(plaintext, new Atbash().decode(ciphertext));
         }
     }
 }

exercises/beer-song/build.gradle

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

exercises/beer-song/src/example/java/BeerSong.java

 public class BeerSong {
-    public static String verse(int number)
-    {
-        switch (number)
-        {
+    public String verse(int number) {
+        switch (number) {
             case 0:
                 return "No more bottles of beer on the wall, no more bottles of beer.\nGo to the store and buy some more, 99 bottles of beer on the wall.\n\n";
             case 1:
         }
     }
 
-    public static String sing(int start, int stop)
-    {
+    public String sing(int start, int stop) {
         StringBuilder songOutput = new StringBuilder();
 
         for (int i=start; i>=stop; i--) {
         return songOutput.toString();
     }
 
-    public static String singSong() {
+    public String singSong() {
         return sing(99,0);
     }
 }

exercises/beer-song/src/test/java/BeerSongTest.java

 import org.junit.Test;
 import org.junit.Ignore;
+import org.junit.Before;
 
 import static org.junit.Assert.assertEquals;
 
 public class BeerSongTest {
 
+    private BeerSong beerSong;
+
+    @Before
+    public void setup(){
+        beerSong = new BeerSong();
+    }
+
     @Test
     public void singFirstVerse() {
         assertEquals("99 bottles of beer on the wall, 99 bottles of beer.\n" +
                         "Take one down and pass it around, 98 bottles of beer on the wall.\n\n",
-                BeerSong.verse(99));
+                beerSong.verse(99));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void singMiddleVerse() {
         assertEquals("44 bottles of beer on the wall, 44 bottles of beer.\n" +
                         "Take one down and pass it around, 43 bottles of beer on the wall.\n\n",
-                BeerSong.verse(44));
+                beerSong.verse(44));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void singThirdToLastVerse() {
         assertEquals("2 bottles of beer on the wall, 2 bottles of beer.\n" +
                         "Take one down and pass it around, 1 bottle of beer on the wall.\n\n",
-                BeerSong.verse(2));
+                beerSong.verse(2));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void singPenultimateVerse() {
         assertEquals("1 bottle of beer on the wall, 1 bottle of beer.\n" +
                         "Take it down and pass it around, no more bottles of beer on the wall.\n\n",
-                BeerSong.verse(1));
+                beerSong.verse(1));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void singLastVerse() {
         assertEquals("No more bottles of beer on the wall, no more bottles of beer.\n" +
                         "Go to the store and buy some more, 99 bottles of beer on the wall.\n\n",
-                BeerSong.verse(0));
+                beerSong.verse(0));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void singLastFourVerses() {
         assertEquals("3 bottles of beer on the wall, 3 bottles of beer.\n" +
                         "Take it down and pass it around, no more bottles of beer on the wall.\n\n" +
                         "No more bottles of beer on the wall, no more bottles of beer.\n" +
                         "Go to the store and buy some more, 99 bottles of beer on the wall.\n\n",
-                BeerSong.sing(3,0));
+                beerSong.sing(3,0));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void singEntireSong() {
         assertEquals("99 bottles of beer on the wall, 99 bottles of beer.\nTake one down and pass it around, 98 bottles of beer on the wall.\n\n" +
                         "2 bottles of beer on the wall, 2 bottles of beer.\nTake one down and pass it around, 1 bottle of beer on the wall.\n\n" +
                         "1 bottle of beer on the wall, 1 bottle of beer.\nTake it down and pass it around, no more bottles of beer on the wall.\n\n" +
                         "No more bottles of beer on the wall, no more bottles of beer.\nGo to the store and buy some more, 99 bottles of beer on the wall.\n\n",
-                BeerSong.singSong());
+                beerSong.singSong());
     }
 
 }

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
+    @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
+    @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
+    @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
+    @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(value -> sut.insert(value));
+        treeData.forEach(bst::insert);
 
-        List<Integer> actual = sut.getAsLevelOrderList();
+        List<Integer> actual = bst.getAsLevelOrderList();
         assertEquals(expected, actual);
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void sortsSingleElement() {
-        BST<Integer> sut = new BST<>();
+        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
-                Arrays.asList(4)
+                Collections.singletonList(4)
         );
 
-        sut.insert(4);
+        bst.insert(4);
 
-        List<Integer> actual = sut.getAsSortedList();
+        List<Integer> actual = bst.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Test
-    @Ignore
+    @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
+    @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
+    @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(value -> sut.insert(value));
+        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
+    @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
+    @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
+    @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
+    @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
+    @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
+    @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
+    @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
+    @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
+    @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/bob/src/test/java/BobTest.java

         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void shouting() {
         assertEquals(
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void askingAQuestion() {
         assertEquals(
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void askingANumericQuestion() {
         assertEquals(
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void talkingForcefully() {
         assertEquals(
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void usingAcronymsInRegularSpeech() {
         assertEquals(
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void forcefulQuestions() {
         assertEquals(
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void shoutingNumbers() {
         assertEquals(
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void onlyNumbers() {
         assertEquals(
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void questionWithOnlyNumbers() {
         assertEquals(
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void shoutingWithSpecialCharacters() {
         assertEquals(
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void shoutingWithUmlauts() {
         assertEquals(
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void calmlySpeakingWithUmlauts() {
         assertEquals(
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void shoutingWithNoExclamationMark() {
         assertEquals(
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void statementContainingQuestionMark() {
         assertEquals(
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void prattlingOn() {
         assertEquals(
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void silence() {
         assertEquals(
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void prolongedSilence() {
         assertEquals(

exercises/book-store/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/book-store/src/example/java/BookStore.java

+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+class BookStore {
+
+  private static final int BOOK_PRICE = 8, MAX_GROUP_SIZE = 5;
+
+  private static double[] DISCOUNT_TIERS = {0, 5, 10, 20, 25};
+
+  double calculateBasketCost(final List<Integer> books) {
+    return calculateBasketCost(books, 0);
+  }
+
+  private double calculateBasketCost(final List<Integer> books, final double priceSoFar) {
+    if (books.size() == 0) {
+      return priceSoFar;
+    }
+
+    List<Integer> availableBookNumbers = books.stream()
+        .distinct()
+        .collect(Collectors.toList());
+
+    double minPrice = Double.MAX_VALUE;
+
+    for (int i = 0; i < availableBookNumbers.size(); i++) {
+      List<Integer> newGroupBooks = new ArrayList<>(availableBookNumbers.subList(0, i + 1));
+      List<Integer> remainingBooks = new ArrayList<>(books);
+
+      for (final Integer newGroupBook : newGroupBooks) {
+        //noinspection UseBulkOperation - we want to remove _one_ of each book number, not _all_ of each book number.
+        remainingBooks.remove(newGroupBook);
+      }
+
+      double price = calculateBasketCost(remainingBooks, priceSoFar + costOfGroupSize(newGroupBooks.size()));
+      minPrice = Math.min(minPrice, price);
+    }
+
+    return minPrice;
+  }
+
+  private double costOfGroupSize(int groupSize) {
+    if (groupSize < 1 || groupSize > MAX_GROUP_SIZE) {
+      throw new IllegalStateException("Invalid group size : " + groupSize);
+    }
+
+    return BOOK_PRICE * groupSize * (100 - DISCOUNT_TIERS[groupSize - 1]) / 100;
+  }
+
+}

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/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/bracket-push/src/test/java/BracketCheckerTest.java

 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
-public final class BracketCheckerTest {
+public class BracketCheckerTest {
 
     @Test
     public void testPairedSquareBrackets() {
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testEmptyString() {
         final BracketChecker bracketChecker = new BracketChecker("");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testUnpairedBrackets() {
         final BracketChecker bracketChecker = new BracketChecker("[[");
         assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testIncorrectlyOrderedBrackets() {
         final BracketChecker bracketChecker = new BracketChecker("}{");
         assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testPairedBracketsWithWhitespace() {
         final BracketChecker bracketChecker = new BracketChecker("{ }");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSimpleNestedBrackets() {
         final BracketChecker bracketChecker = new BracketChecker("{[]}");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSeveralPairedBrackets() {
         final BracketChecker bracketChecker = new BracketChecker("{}[]");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testPairedAndNestedBrackets() {
         final BracketChecker bracketChecker = new BracketChecker("([{}({}[])])");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testUnopenedClosingBracket() {
         final BracketChecker bracketChecker = new BracketChecker("{[)][]}");
         assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testUnpairedAndNestedBracket() {
         final BracketChecker bracketChecker = new BracketChecker("([{])");
         assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testPairedAndIncorrectlyNestedBrackets() {
         final BracketChecker bracketChecker = new BracketChecker("[({]})");
         assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testValidMathExpression() {
         final BracketChecker bracketChecker = new BracketChecker("(((185 + 223.85) * 15) - 543)/2");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testValidComplexLaTeXExpression() {
         final BracketChecker bracketChecker = new 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
                 changeCalculator.computeMostEfficientChange(25));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testChangeThatMustBeGivenInMultipleCoins() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 5, 10, 25, 100));
                 changeCalculator.computeMostEfficientChange(15));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     // https://en.wikipedia.org/wiki/Change-making_problem#Greedy_method
     public void testLilliputianCurrencyForWhichGreedyAlgorithmFails() {
                 changeCalculator.computeMostEfficientChange(23));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     // https://en.wikipedia.org/wiki/Change-making_problem#Greedy_method
     public void testLowerElbonianCurrencyForWhichGreedyAlgorithmFails() {
                 changeCalculator.computeMostEfficientChange(63));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLargeAmountOfChange() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 2, 5, 10, 20, 50, 100));
                 changeCalculator.computeMostEfficientChange(999));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testZeroChange() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 5, 10, 21, 25));
                 changeCalculator.computeMostEfficientChange(0));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testChangeLessThanSmallestCoinInCurrencyCannotBeRepresented() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(5, 10));
         changeCalculator.computeMostEfficientChange(3);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testChangeLargerThanAllCoinsInCurrencyThatCannotBeRepresented() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(5, 10));
         changeCalculator.computeMostEfficientChange(94);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testNegativeChangeIsRejected() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 2, 5));

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
+    @Ignore("Remove to run test")
     @Test
     public void addMinutes() {
         Clock clock = new Clock(10, 0);
         assertEquals("10:03", clock.toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void addNoMinutes() {
         Clock clock = new Clock(6, 41);
         assertEquals("06:41", clock.toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void addToNextHour() {
         Clock clock = new Clock(0, 45);
         assertEquals("01:25", clock.toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void addMoreThanOneHour() {
         Clock clock = new Clock(10, 0);
         assertEquals("11:01", clock.toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void addMoreThanTwoHoursWithCarry() {
         Clock clock = new Clock(0, 45);
         assertEquals("03:25", clock.toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void addAcrossMidnight() {
         Clock clock = new Clock(23, 59);
         assertEquals("00:01", clock.toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void addMoreThanOneDay() {
         Clock clock = new Clock(5, 32);
         assertEquals("06:32", clock.toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void addMoreThanTwoDays() {
         Clock clock = new Clock(1, 1);
         assertEquals("11:21", clock.toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void subtractMinutes() {
         Clock clock = new Clock(10, 3);
         assertEquals("10:00", clock.toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void subtractToPreviousHour() {
         Clock clock = new Clock(10, 3);
         assertEquals("09:33", clock.toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void subtractMoreThanAnHour() {
         Clock clock = new Clock(10, 3);
         assertEquals("08:53", clock.toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void subtractAcrossMidnight() {
         Clock clock = new Clock(0, 3);
         assertEquals("23:59", clock.toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void subtractMoreThanTwoHours() {
         Clock clock = new Clock(0, 0);
         assertEquals("21:20", clock.toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void subtractMoreThanTwoHoursWithBorrow() {
         Clock clock = new Clock(6, 15);
         assertEquals("03:35", clock.toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void subtractMoreThanOneDay() {
         Clock clock = new Clock(5, 32);
         assertEquals("04:32", clock.toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void subtractMoreThanTwoDays() {
         Clock clock = new Clock(2, 20);

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

 
 import static org.junit.Assert.assertEquals;
 
+/*
+ * version: 1.0.1
+ */
 public class ClockCreationTest {
 
     @Test
         assertEquals("08:00", new Clock(8, 0).toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void canPrintTimeWithMinutes() {
         assertEquals("11:09", new Clock(11, 9).toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void midnightPrintsAsZero() {
         assertEquals("00:00", new Clock(24, 0).toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void hourRollsOver() {
         assertEquals("01:00", new Clock(25, 0).toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void hourRollsOverContinuously() {
         assertEquals("04:00", new Clock(100, 0).toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void sixtyMinutesIsNextHour() {
         assertEquals("02:00", new Clock(1, 60).toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void minutesRollOver() {
         assertEquals("02:40", new Clock(0, 160).toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void minutesRollOverContinuously() {
         assertEquals("04:43", new Clock(0, 1723).toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void hourAndMinutesRollOver() {
         assertEquals("03:40", new Clock(25, 160).toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void hourAndMinutesRollOverContinuously() {
         assertEquals("11:01", new Clock(201, 3001).toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void hourAndMinutesRollOverToExactlyMidnight() {
         assertEquals("00:00", new Clock(72, 8640).toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void negativeHour() {
         assertEquals("23:15", new Clock(-1, 15).toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void negativeHourRollsOver() {
         assertEquals("23:00", new Clock(-25, 0).toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void negativeHourRollsOverContinuously() {
         assertEquals("05:00", new Clock(-91, 0).toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void negativeMinutes() {
         assertEquals("00:20", new Clock(1, -40).toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void negativeMinutesRollOver() {
         assertEquals("22:20", new Clock(1, -160).toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void negativeMinutesRollOverContinuously() {
         assertEquals("16:40", new Clock(1, -4820).toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void negativeHourAndMinutesBothRollOver() {
         assertEquals("20:20", new Clock(-25, -160).toString());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void negativeHourAndMinutesBothRollOverContinuously() {
         assertEquals("22:10", new Clock(-121, -5810).toString());

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
+    @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
+    @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
+    @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
+    @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
+    @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
+    @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
+    @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
+    @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
+    @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
+    @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
+    @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
+    @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
+    @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
+    @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
+    @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/crypto-square/src/test/java/CryptoSquareTest.java

         assertEquals(expectedOutput, crypto.getNormalizedPlaintext());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void lettersAreLowerCasedDuringNormalization() {
         Crypto crypto = new Crypto("WHOA HEY!");
         assertEquals(expectedOutput, crypto.getNormalizedPlaintext());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void numbersAreKeptDuringNormalization() {
         Crypto crypto = new Crypto("1, 2, 3, GO!");
         assertEquals(expectedOutput, crypto.getNormalizedPlaintext());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void smallestSquareSizeIs2() {
         Crypto crypto = new Crypto("1234");
         assertEquals(expectedOutput, crypto.getSquareSize());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void sizeOfTextWhoseLengthIsPerfectSquareIsItsSquareRoot() {
         Crypto crypto = new Crypto("123456789");
         assertEquals(expectedOutput, crypto.getSquareSize());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void sizeOfTextWhoseLengthIsNoPerfectSquareIsNextBiggestSquareRoot() {
         Crypto crypto = new Crypto("123456789abc");
         assertEquals(expectedOutput, crypto.getSquareSize());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void sizeIsDeterminedByNormalizedText() {
         Crypto crypto = new Crypto("Oh hey, this is nuts!");
         assertEquals(expectedOutput, crypto.getSquareSize());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void segmentsAreSplitBySquareSize() {
         Crypto crypto = new Crypto("Never vex thine heart with idle woes");
         assertEquals(expectedOutput, crypto.getPlaintextSegments());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void segmentsAreSplitBySquareSizeUntilTextRunsOut() {
         Crypto crypto = new Crypto("ZOMG! ZOMBIES!!!");
         assertEquals(expectedOutput, crypto.getPlaintextSegments());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cipherTextCombinesTextByColumn() {
         Crypto crypto = new Crypto("First, solve the problem. Then, write the code.");
         assertEquals(expectedOutput, crypto.getCipherText());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cipherTextSkipsCellsWithNoText() {
         Crypto crypto = new Crypto("Time is an illusion. Lunchtime doubly so.");
         assertEquals(expectedOutput, crypto.getCipherText());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void normalizedCipherTextIsSplitByHeightOfSquare() {
         Crypto crypto = new Crypto("Vampires are people too!");
         assertEquals(expectedOutput, crypto.getNormalizedCipherText());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void normalizedCipherNotExactlyDivisibleBy5SpillsIntoSmallerSegment() {
         Crypto crypto = new Crypto("Madness, and then illumination.");
         assertEquals(expectedOutput, crypto.getNormalizedCipherText());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void normalizedCipherIsSplitIntoSegmentsOfCorrectSize() {
         Crypto crypto = new Crypto("If man was meant to stay on the ground god would have given us roots");
         assertEquals(expectedOutput, crypto.getNormalizedCipherText());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void normalizedCipherTextIsSplitIntoSegmentsOfCorrectSizeWithPunctuation() {
         Crypto crypto = new Crypto("Have a nice day. Feed the dog & chill out!");

exercises/custom-set/src/test/java/CustomSetTest.java

     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void setsWithElementsAreNotEmpty() {
         final boolean actual
                 = new CustomSet<>(Arrays.asList(1))
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void nothingIsContainedInAnEmptySet() {
         final boolean actual
                 = new CustomSet<>(Collections.EMPTY_LIST)
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void whenTheElementIsInTheSet() {
         final boolean actual
                 = new CustomSet<>(Arrays.asList(1, 2, 3))
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void whenTheElementIsNotInTheSet() {
         final boolean actual
                 = new CustomSet<>(Arrays.asList(1, 2, 3))
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void emptySetIsASubsetOfAnotherEmptySet() {
         final boolean actual
                 = new CustomSet<>(Collections.EMPTY_LIST)
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void emptySetIsASubsetOfNonEemptySet() {
         final boolean actual
                 = new CustomSet<>(Arrays.asList(1))
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void nonEmptySetIsNotASubsetOfEmptySet() {
         final boolean actual
                 = new CustomSet<>(Collections.EMPTY_LIST)
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void setIsASubsetOfSetWithExactSameElements() {
         final boolean actual
                 = new CustomSet<>(Arrays.asList(1, 2, 3))
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void setIsASubsetOfLargerSetWithSameElements() {
         final boolean actual
                 = new CustomSet<>(Arrays.asList(4, 1, 2, 3))
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void setIsNotASubsetOfSetThatDoesNotContainItsElements() {
         final boolean actual
                 = new CustomSet<>(Arrays.asList(4, 1, 3))
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void theEmptySetIsDisjointWithItself() {
         final boolean actual
                 = new CustomSet<>(Collections.EMPTY_LIST)
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void emptySetIsDisjointWithNonEmptySet() {
         final boolean actual
                 = new CustomSet<>(Collections.EMPTY_LIST)
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void nonEmptySetIsDisjointWithEmptySet() {
         final boolean actual
                 = new CustomSet<>(Arrays.asList(1))
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void setsAreNotDisjointIfTheyShareAnElement() {
         final boolean actual
                 = new CustomSet<>(Arrays.asList(1, 2))
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void setsAreDisjointIfTheyShareNoElements() {
         final boolean actual
                 = new CustomSet<>(Arrays.asList(1, 2))
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void emptySetsAreEqual() {
         final boolean actual
                 = new CustomSet<>(Collections.EMPTY_LIST)
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void emptySetIsNotEqualToNonEmptySet() {
         final boolean actual
                 = new CustomSet<>(Collections.EMPTY_LIST)
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void nonEmptySetIsNotEqualToEmptySet() {
         final boolean actual
                 = new CustomSet<>(Arrays.asList(1, 2, 3))
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void setsWithTheSameElementsAreEqual() {
         final boolean actual
                 = new CustomSet<>(Arrays.asList(1, 2))
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void setsWithDifferentElementsAreNotEqual() {
         final boolean actual
                 = new CustomSet<>(Arrays.asList(1, 2, 3))
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void addToEmptySet() {
         final int element = 3;
         final CustomSet<Integer> expected
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void addToNonEmptySet() {
         final int element = 3;
         final CustomSet<Integer> expected
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void addingAnExistingElementDoesNotChangeTheSet() {
         final int element = 3;
         final CustomSet<Integer> expected
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void intersectionOfTwoEmptySetsIsAnEmptySet() {
         final CustomSet<Integer> actual
                 = new CustomSet<>(Collections.EMPTY_LIST)
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void intersectionOfAnEmptySetAndNonEmptySetIsAnEmptySet() {
         final CustomSet<Integer> actual
                 = new CustomSet<>(Collections.EMPTY_LIST)
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void intersectionOfANonEmptySetAndAnEmptySetIsAnEmptySet() {
         final CustomSet<Integer> actual
                 = new CustomSet<>(Arrays.asList(1, 2, 3, 4))
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void intersectionOfTwoSetsWithNoSharedElementsIsAnEmptySet() {
         final CustomSet<Integer> actual
                 = new CustomSet<>(Arrays.asList(1, 2, 3))
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void intersectionOfTwoSetsWithSharedElementsIsASetOfTheSharedElements() {
         final CustomSet<Integer> expected
                 = new CustomSet<>(
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void differenceOfTwoEmptySetsIsAnEmptySet() {
         final CustomSet<Integer> actual
                 = new CustomSet<>(Collections.EMPTY_LIST)
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void differenceOfAnEmptySetAndNonEmptySetIsAnEmptySet() {
         final CustomSet<Integer> actual
                 = new CustomSet<>(Collections.EMPTY_LIST)
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void differenceOfANonEmptySetAndAnEmptySetIsTheNonEmptySet() {
         final CustomSet<Integer> expected
                 = new CustomSet<>(
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void differenceOfTwoNonEmptySetsIsASetOfElementsThatAreOnlyInTheFirstSet() {
         final CustomSet<Integer> expected
                 = new CustomSet<>(
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void unionOfTwoEmptySetsIsAnEmptySet() {
         final CustomSet<Integer> actual
                 = new CustomSet<>(Collections.EMPTY_LIST)
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void unionOfAnEmptySetAndNonEmptySetIsTheNonEmptySet() {
         final CustomSet<Integer> expected
                 = new CustomSet<>(
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void unionOfANonEmptySetAndAnEmptySetIsTheNonEmptySet() {
         final CustomSet<Integer> expected
                 = new CustomSet<>(
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void unionOfTwoNonEmptySetsContainsAllUniqueElements() {
         final CustomSet<Integer> expected
                 = new CustomSet<>(

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 org.junit.Ignore;
+import org.junit.Before;
 import org.junit.Test;
 
 import java.util.List;
 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertThat;
 
-public final class DiamondPrinterTest {
+/*
+ * version: 1.0.0
+ */
+public class DiamondPrinterTest {
+
+    private DiamondPrinter diamondPrinter;
+
+    @Before
+    public void setUp() {
+        diamondPrinter = new DiamondPrinter();
+    }
 
     @Test
     public void testOneByOneDiamond() {
-        List<String> output = new DiamondPrinter().printToList('A');
+        List<String> output = diamondPrinter.printToList('A');
         assertThat(output, is(singletonList("A")));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTwoByTwoDiamond() {
-        List<String> output = new DiamondPrinter().printToList('B');
+        List<String> output = diamondPrinter.printToList('B');
         assertThat(output, is(asList(" A ",
                                      "B B",
                                      " A ")));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThreeByThreeDiamond() {
-        List<String> output = new DiamondPrinter().printToList('C');
+        List<String> output = diamondPrinter.printToList('C');
         assertThat(output, is(asList("  A  ",
                                      " B B ",
                                      "C   C",
                                      "  A  ")));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFiveByFiveDiamond() {
-        List<String> output = new DiamondPrinter().printToList('E');
+        List<String> output = diamondPrinter.printToList('E');
         assertThat(output, is(asList("    A    ",
                                      "   B B   ",
                                      "  C   C  ",
                                      "    A    ")));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFullDiamond() {
-        List<String> output = new DiamondPrinter().printToList('Z');
+        List<String> output = diamondPrinter.printToList('Z');
         assertThat(output, is(asList("                         A                         ",
                                      "                        B B                        ",
                                      "                       C   C                       ",

exercises/difference-of-squares/build.gradle

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

exercises/difference-of-squares/src/example/java/Difference.java → exercises/difference-of-squares/src/example/java/DifferenceOfSquaresCalculator.java

 import java.util.stream.IntStream;
 
-public final class Difference {
+final class DifferenceOfSquaresCalculator {
 
-    public static int computeSquareOfSumTo(final int input) {
+    int computeSquareOfSumTo(final int input) {
         final int sum = input * (input + 1) / 2;
         return (int) Math.pow(sum, 2);
     }
 
-    public static int computeSumOfSquaresTo(final int input) {
+    int computeSumOfSquaresTo(final int input) {
         return IntStream.rangeClosed(1, input)
                 .map(i -> (int) Math.pow(i, 2))
                 .sum();
     }
 
-    public static int betweenSquareOfSumAndSumOfSquaresTo(final int input) {
+    int computeDifferenceOfSquares(final int input) {
         return computeSquareOfSumTo(input) - computeSumOfSquaresTo(input);
     }
 

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

-public final class Difference {
-    
-
-
-}

exercises/difference-of-squares/src/test/java/DifferenceOfSquaresCalculatorTest.java

+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/*
+ * version: 1.1.0
+ */
+public class DifferenceOfSquaresCalculatorTest {
+
+    private DifferenceOfSquaresCalculator calculator;
+
+    @Before
+    public void setUp() {
+        calculator = new DifferenceOfSquaresCalculator();
+    }
+
+    @Test
+    public void testSquareOfSum1() {
+        final int expected = 1;
+        final int actual = calculator.computeSquareOfSumTo(1);
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSquareOfSum5() {
+        final int expected = 225;
+        final int actual = calculator.computeSquareOfSumTo(5);
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSquareOfSum100() {
+        final int expected = 25502500;
+        final int actual = calculator.computeSquareOfSumTo(100);
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSumOfSquares1() {
+        final int expected = 1;
+        final int actual = calculator.computeSumOfSquaresTo(1);
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSumOfSquares5() {
+        final int expected = 55;
+        final int actual = calculator.computeSumOfSquaresTo(5);
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSumOfSquares100() {
+        final int expected = 338350;
+        final int actual = calculator.computeSumOfSquaresTo(100);
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDifferenceOfSquares1() {
+        final int expected = 0;
+        final int actual = calculator.computeDifferenceOfSquares(1);
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDifferenceOfSquares5() {
+        final int expected = 170;
+        final int actual = calculator.computeDifferenceOfSquares(5);
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDifferenceOfSquares100() {
+        final int expected = 25164150;
+        final int actual = calculator.computeDifferenceOfSquares(100);
+        assertEquals(expected, actual);
+    }
+
+}

exercises/difference-of-squares/src/test/java/DifferenceTest.java

-import org.junit.Ignore;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-public final class DifferenceTest {
-
-    @Test
-    public void testSquareOfSum5() {
-        final int expected = 225;
-        final int actual = Difference.computeSquareOfSumTo(5);
-        assertEquals(expected, actual);
-    }
-
-    @Ignore
-    @Test
-    public void testSquareOfSum10() {
-        final int expected = 3025;
-        final int actual = Difference.computeSquareOfSumTo(10);
-        assertEquals(expected, actual);
-    }
-
-    @Ignore
-    @Test
-    public void testSquareOfSum100() {
-        final int expected = 25502500;
-        final int actual = Difference.computeSquareOfSumTo(100);
-        assertEquals(expected, actual);
-    }
-
-    @Ignore
-    @Test
-    public void testSumOfSquares5() {
-        final int expected = 55;
-        final int actual = Difference.computeSumOfSquaresTo(5);
-        assertEquals(expected, actual);
-    }
-
-    @Ignore
-    @Test
-    public void testSumOfSquares10() {
-        final int expected = 385;
-        final int actual = Difference.computeSumOfSquaresTo(10);
-        assertEquals(expected, actual);
-    }
-
-    @Ignore
-    @Test
-    public void testSumOfSquares100() {
-        final int expected = 338350;
-        final int actual = Difference.computeSumOfSquaresTo(100);
-        assertEquals(expected, actual);
-    }
-
-    @Ignore
-    @Test
-    public void testDifferenceOfSquares0() {
-        final int expected = 0;
-        final int actual = Difference.betweenSquareOfSumAndSumOfSquaresTo(0);
-        assertEquals(expected, actual);
-    }
-
-    @Ignore
-    @Test
-    public void testDifferenceOfSquares5() {
-        final int expected = 170;
-        final int actual = Difference.betweenSquareOfSumAndSumOfSquaresTo(5);
-        assertEquals(expected, actual);
-    }
-
-    @Ignore
-    @Test
-    public void testDifferenceOfSquares10() {
-        final int expected = 2640;
-        final int actual = Difference.betweenSquareOfSumAndSumOfSquaresTo(10);
-        assertEquals(expected, actual);
-    }
-
-    @Ignore
-    @Test
-    public void testDifferenceOfSquares100() {
-        final int expected = 25164150;
-        final int actual = Difference.betweenSquareOfSumAndSumOfSquaresTo(100);
-        assertEquals(expected, actual);
-    }
-
-}

exercises/etl/build.gradle

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

exercises/etl/src/test/java/EtlTest.java

         assertEquals(expected, etl.transform(old));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTransformMoreValues() {
         Map<Integer, List<String>> old = new HashMap<Integer, List<String>>() {
         assertEquals(expected, etl.transform(old));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testMoreKeys() {
         Map<Integer, List<String>> old = new HashMap<Integer, List<String>>() {
         assertEquals(expected, etl.transform(old));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFullDataset() {
         Map<Integer, List<String>> old = new HashMap<Integer, List<String>>() {

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/flatten-array/src/test/java/FlattenerTest.java

 import static java.util.Collections.singletonList;
 import static org.junit.Assert.assertEquals;
 
-public final class FlattenerTest {
+/*
+ * version: 1.1.0
+ */
+public class FlattenerTest {
 
     private Flattener flattener;
 
     }
 
     @Test
+    public void testFlatListIsPreserved() {
+        assertEquals(
+          asList(0, '1', "two"),
+            flattener.flatten(
+              asList(
+                0,
+                '1',
+                "two")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
     public void testASingleLevelOfNestingWithNoNulls() {
         assertEquals(
           asList(1, '2', 3, 4, 5, "six", "7", 8),
               8)));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFiveLevelsOfNestingWithNoNulls() {
         assertEquals(
               "-2")));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSixLevelsOfNestingWithNoNulls() {
         assertEquals(
               "8")));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSixLevelsOfNestingWithNulls() {
         assertEquals(
               "negative two")));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testNestedListsFullOfNullsOnly() {
         assertEquals(

exercises/gigasecond/build.gradle

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

exercises/gigasecond/src/example/java/Gigasecond.java

 import java.time.LocalDateTime;
 import java.time.LocalDate;
 
-public class Gigasecond {
+class Gigasecond {
 
     private LocalDateTime birthDateTime;
 
-    public Gigasecond(LocalDateTime birthDateTime) {
-        this.birthDateTime = birthDateTime;
+    Gigasecond(LocalDate birthDate) {
+        this.birthDateTime = birthDate.atTime(0, 0);
     }
 
-    public Gigasecond(LocalDate birthDate) {
-        this.birthDateTime = birthDate.atTime(0, 0);
+    Gigasecond(LocalDateTime birthDateTime) {
+        this.birthDateTime = birthDateTime;
     }
 
-    public LocalDateTime getDate() {
+    LocalDateTime getDate() {
         return birthDateTime.plusSeconds(1000000000);
     }
+
 }

exercises/gigasecond/src/main/java/Gigasecond.java

+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+class Gigasecond {
+
+    Gigasecond(LocalDate birthDate) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    Gigasecond(LocalDateTime birthDateTime) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    LocalDateTime getDate() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

exercises/gigasecond/src/test/java/GigasecondTest.java

 
 public class GigasecondTest {
 
-
     @Test
     public void modernTime() {
         Gigasecond gigaSecond = new Gigasecond(LocalDate.of(2011, Month.APRIL, 25));
         assertEquals(LocalDateTime.of(2043, Month.JANUARY, 1, 1, 46, 40), gigaSecond.getDate());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void afterEpochTime() {
         Gigasecond gigaSecond = new Gigasecond(LocalDate.of(1977, Month.JUNE, 13));
         assertEquals(LocalDateTime.of(2009, Month.FEBRUARY, 19, 1, 46, 40), gigaSecond.getDate());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void beforeEpochTime() {
         Gigasecond gigaSecond = new Gigasecond(LocalDate.of(1959, Month.JULY, 19));
         assertEquals(LocalDateTime.of(1991, Month.MARCH, 27, 1, 46, 40), gigaSecond.getDate());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void withFullTimeSpecified() {
         Gigasecond gigaSecond = new Gigasecond(LocalDateTime.of(2015, Month.JANUARY, 24, 22, 0, 0));
         assertEquals(LocalDateTime.of(2046, Month.OCTOBER, 2, 23, 46, 40), gigaSecond.getDate());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void withFullTimeSpecifiedAndDayRollover() {
         Gigasecond gigaSecond = new Gigasecond(LocalDateTime.of(2015, Month.JANUARY, 24, 23, 59, 59));

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/grade-school/src/test/java/SchoolTest.java

+import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
 
 public class SchoolTest {
-  private final School school = new School();
+  private School school;
+
+  @Before
+  public void setUp() {
+    school = new School();
+  }
 
   @Test
   public void startsWithNoStudents() {
     assertThat(school.numberOfStudents(), is(0));
   }
 
-  @Ignore
+  @Ignore("Remove to run test")
   @Test
   public void addsStudents() {
     school.add("Aimee", 2);
     assertThat(school.grade(2), hasItem("Aimee"));
   }
 
-  @Ignore
+  @Ignore("Remove to run test")
   @Test
   public void addsMoreStudentsInSameGrade() {
     final int grade = 2;
     assertThat(school.grade(grade), allOf(hasItem("James"), hasItem("Blair"), hasItem("Paul")));
   }
 
-  @Ignore
+  @Ignore("Remove to run test")
   @Test
   public void addsStudentsInMultipleGrades() {
     school.add("Chelsea", 3);
     assertThat(school.grade(7), hasItem("Logan"));
   }
 
-  @Ignore
+  @Ignore("Remove to run test")
   @Test
   public void getsStudentsInEmptyGrade() {
     assertTrue(school.grade(1).isEmpty());
   }
 
-  @Ignore
+  @Ignore("Remove to run test")
   @Test
   public void sortsSchool() {
     school.add("Kyle", 4);
     }
   }
 
-  @Ignore
+  @Ignore("Remove to run test")
   @Test
   public void modifyingFetchedGradeShouldNotModifyInternalDatabase() {
     String shouldNotBeAdded = "Should not be added to school";
     assertThat(school.grade(grade), not(hasItem(shouldNotBeAdded)));
   }
 
-  @Ignore
+  @Ignore("Remove to run test")
   @Test
   public void modifyingSortedStudentsShouldNotModifyInternalDatabase() {
     int grade = 2;
       // Such as UnsupportedOperationException when an unmodifiableMap is used
     }
 
-    assertThat(school.studentsByGradeAlphabetical().get(grade), 
+    assertThat(school.studentsByGradeAlphabetical().get(grade),
       not(hasItem(studentWhichShouldNotBeAdded)));
   }
 }

exercises/hamming/build.gradle

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

exercises/hamming/src/example/java/Hamming.java

 public class Hamming {
+    private final int hammingDistance;
 
-    public static int compute(String leftStrand, String rightStrand) {
+    public Hamming(String leftStrand, String rightStrand) {
+        hammingDistance = computeHammingDistance(leftStrand, rightStrand);
+    }
+
+    public int getHammingDistance() {
+        return hammingDistance;
+    }
+
+    private int computeHammingDistance(String leftStrand, String rightStrand) {
         if(leftStrand.length() != rightStrand.length()) {
             throw new IllegalArgumentException("leftStrand and rightStrand must be of equal length.");
         }
         return distance;
     }
 
-    private static int hammingContributionAt(int index, String leftStrand, String rightStrand) {
+    private int hammingContributionAt(int index, String leftStrand, String rightStrand) {
       return leftStrand.charAt(index) != rightStrand.charAt(index) ? 1 : 0;
     }
 

exercises/hamming/src/main/java/Hamming.java

 public class Hamming {
+
+    Hamming(String leftStrand, String rightStrand) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    int getHammingDistance() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
 }

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

 import org.junit.rules.ExpectedException;
 
 public class HammingTest {
-    
 
     @Rule
     public ExpectedException thrown = ExpectedException.none();
     
     @Test
     public void testNoDifferenceBetweenIdenticalStrands() {
-        assertThat(Hamming.compute("A", "A"), is(0));
+        assertThat(new Hamming("A", "A").getHammingDistance(), is(0));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testHammingDistanceForSingleNucleotideStrand() {
-        assertThat(Hamming.compute("A", "G"), is(1));
+        assertThat(new Hamming("A", "G").getHammingDistance(), is(1));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testHammingDistanceForSmallStrand() {
-        assertThat(Hamming.compute("AG", "CT"), is(2)); 
+        assertThat(new Hamming("AG", "CT").getHammingDistance(), is(2));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSmallHammingDistance() {
-        assertThat(Hamming.compute("AT", "CT"), is(1));
+        assertThat(new Hamming("AT", "CT").getHammingDistance(), is(1));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSmallHammingDistanceInLongerStrand() {
-        assertThat(Hamming.compute("GGACG", "GGTCG"), is(1));
+        assertThat(new Hamming("GGACG", "GGTCG").getHammingDistance(), is(1));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testValidatesFirstStrandNotLonger() {
         thrown.expect(IllegalArgumentException.class);
-        Hamming.compute("AAAG", "AAA");                
+        new Hamming("AAAG", "AAA");
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testValidatesOtherStrandNotLonger() {
         thrown.expect(IllegalArgumentException.class);
-        Hamming.compute("AAA", "AAAG");
+        new Hamming("AAA", "AAAG");
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLargeHammingDistance() {
-        assertThat(Hamming.compute("GATACA", "GCATAA"), is(4));
+        assertThat(new Hamming("GATACA", "GCATAA").getHammingDistance(), is(4));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testHammingDistanceInVeryLongStrand() {
-        assertThat(Hamming.compute("GGACGGATTCTG", "AGGACGGATTCT"), is(9));
+        assertThat(new Hamming("GGACGGATTCTG", "AGGACGGATTCT").getHammingDistance(), is(9));
     }
 
 }

exercises/hello-world/GETTING_STARTED.md

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