Merge branch 'master' into MatrixExercise

config.json

     "palindrome-products",
     "twelve-days",
     "sublist",
+    "rectangles",
     "matrix"
   ],
   "exercises": [
       "topics": []
     },
     {
+      "slug": "rectangles",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
       "slug": "matrix",
       "difficulty": 1,
       "topics": []

docs/MAINTAINING.md

+# Welcome!
+
+This is a guide/reference for maintainers of the Java track.
+
+- [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.
+
+### Track-specific
+
+- [xjava](https://github.com/exercism/xjava) — yeah... you know what this one is. :)
+
+### Exercism-wide
+
+- [x-common](https://github.com/exercism/x-common) — 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.
+
+## Maintainer Guides
+
+- **[exercism.io/docs/maintaining-a-track.md](https://github.com/exercism/exercism.io/blob/master/docs/maintaining-a-track.md)**
+- [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).
+  This label is described in [discussions#96](https://github.com/exercism/discussions/issues/96).
+- Exercism has a Twitter account: [@Exercism.io](https://twitter.com/exercism_io); and a mailing list: https://tinyletter.com/exercism
+
+**Please feel free to ask any questions.  In our thinking, asking questions is far smarter than guessing.**

exercises/meetup/src/test/java/MeetupTest.java

     public void test_monteenth_of_may_2013() {
         LocalDate expected = LocalDate.of(2013, 5, 13);
         Meetup meetup = new Meetup(5, 2013);
-        assertEquals(meetup.day(DayOfWeek.MONDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_monteenth_of_august_2013() {
         LocalDate expected = LocalDate.of(2013, 8, 19);
         Meetup meetup = new Meetup(8, 2013);
-        assertEquals(meetup.day(DayOfWeek.MONDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_monteenth_of_september_2013() {
         LocalDate expected = LocalDate.of(2013, 9, 16);
         Meetup meetup = new Meetup(9, 2013);
-        assertEquals(meetup.day(DayOfWeek.MONDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_tuesteenth_of_march_2013() {
         LocalDate expected = LocalDate.of(2013, 3, 19);
         Meetup meetup = new Meetup(3, 2013);
-        assertEquals(meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_tuesteenth_of_april_2013() {
         LocalDate expected = LocalDate.of(2013, 4, 16);
         Meetup meetup = new Meetup(4, 2013);
-        assertEquals(meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_tuesteenth_of_august_2013() {
         LocalDate expected = LocalDate.of(2013, 8, 13);
         Meetup meetup = new Meetup(8, 2013);
-        assertEquals(meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_wednesteenth_of_january_2013() {
         LocalDate expected = LocalDate.of(2013, 1, 16);
         Meetup meetup = new Meetup(1, 2013);
-        assertEquals(meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_wednesteenth_of_february_2013() {
         LocalDate expected = LocalDate.of(2013, 2, 13);
         Meetup meetup = new Meetup(2, 2013);
-        assertEquals(meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_wednesteenth_of_june_2013() {
         LocalDate expected = LocalDate.of(2013, 6, 19);
         Meetup meetup = new Meetup(6, 2013);
-        assertEquals(meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_thursteenth_of_may_2013() {
         LocalDate expected = LocalDate.of(2013, 5, 16);
         Meetup meetup = new Meetup(5, 2013);
-        assertEquals(meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_thursteenth_of_june_2013() {
         LocalDate expected = LocalDate.of(2013, 6, 13);
         Meetup meetup = new Meetup(6, 2013);
-        assertEquals(meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_thursteenth_of_september_2013() {
         LocalDate expected = LocalDate.of(2013, 9, 19);
         Meetup meetup = new Meetup(9, 2013);
-        assertEquals(meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_friteenth_of_april_2013() {
         LocalDate expected = LocalDate.of(2013, 4, 19);
         Meetup meetup = new Meetup(4, 2013);
-        assertEquals(meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_friteenth_of_august_2013() {
         LocalDate expected = LocalDate.of(2013, 8, 16);
         Meetup meetup = new Meetup(8, 2013);
-        assertEquals(meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_friteenth_of_september_2013() {
         LocalDate expected = LocalDate.of(2013, 9, 13);
         Meetup meetup = new Meetup(9, 2013);
-        assertEquals(meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_saturteenth_of_february_2013() {
         LocalDate expected = LocalDate.of(2013, 2, 16);
         Meetup meetup = new Meetup(2, 2013);
-        assertEquals(meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_saturteenth_of_april_2013() {
         LocalDate expected = LocalDate.of(2013, 4, 13);
         Meetup meetup = new Meetup(4, 2013);
-        assertEquals(meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_saturteenth_of_october_2013() {
         LocalDate expected = LocalDate.of(2013, 10, 19);
         Meetup meetup = new Meetup(10, 2013);
-        assertEquals(meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_sunteenth_of_may_2013() {
         LocalDate expected = LocalDate.of(2013, 5, 19);
         Meetup meetup = new Meetup(5, 2013);
-        assertEquals(meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_sunteenth_of_june_2013() {
         LocalDate expected = LocalDate.of(2013, 6, 16);
         Meetup meetup = new Meetup(6, 2013);
-        assertEquals(meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_sunteenth_of_october_2013() {
         LocalDate expected = LocalDate.of(2013, 10, 13);
         Meetup meetup = new Meetup(10, 2013);
-        assertEquals(meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.TEENTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.TEENTH));
     }
 
     @Ignore
     public void test_first_monday_of_march_2013() {
         LocalDate expected = LocalDate.of(2013, 3, 4);
         Meetup meetup = new Meetup(3, 2013);
-        assertEquals(meetup.day(DayOfWeek.MONDAY, MeetupSchedule.FIRST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.FIRST));
     }
 
     @Ignore
     public void test_first_monday_of_april_2013() {
         LocalDate expected = LocalDate.of(2013, 4, 1);
         Meetup meetup = new Meetup(4, 2013);
-        assertEquals(meetup.day(DayOfWeek.MONDAY, MeetupSchedule.FIRST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.FIRST));
     }
 
     @Ignore
     public void test_first_tuesday_of_may_2013() {
         LocalDate expected = LocalDate.of(2013, 5, 7);
         Meetup meetup = new Meetup(5, 2013);
-        assertEquals(meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.FIRST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.FIRST));
     }
 
     @Ignore
     public void test_first_tuesday_of_june_2013() {
         LocalDate expected = LocalDate.of(2013, 6, 4);
         Meetup meetup = new Meetup(6, 2013);
-        assertEquals(meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.FIRST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.FIRST));
     }
 
     @Ignore
     public void test_first_wednesday_of_july_2013() {
         LocalDate expected = LocalDate.of(2013, 7, 3);
         Meetup meetup = new Meetup(7, 2013);
-        assertEquals(meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.FIRST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.FIRST));
     }
 
     @Ignore
     public void test_first_wednesday_of_august_2013() {
         LocalDate expected = LocalDate.of(2013, 8, 7);
         Meetup meetup = new Meetup(8, 2013);
-        assertEquals(meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.FIRST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.FIRST));
     }
 
     @Ignore
     public void test_first_thursday_of_september_2013() {
         LocalDate expected = LocalDate.of(2013, 9, 5);
         Meetup meetup = new Meetup(9, 2013);
-        assertEquals(meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.FIRST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.FIRST));
     }
 
     @Ignore
     public void test_first_thursday_of_october_2013() {
         LocalDate expected = LocalDate.of(2013, 10, 3);
         Meetup meetup = new Meetup(10, 2013);
-        assertEquals(meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.FIRST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.FIRST));
     }
 
     @Ignore
     public void test_first_friday_of_november_2013() {
         LocalDate expected = LocalDate.of(2013, 11, 1);
         Meetup meetup = new Meetup(11, 2013);
-        assertEquals(meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.FIRST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.FIRST));
     }
 
     @Ignore
     public void test_first_friday_of_december_2013() {
         LocalDate expected = LocalDate.of(2013, 12, 6);
         Meetup meetup = new Meetup(12, 2013);
-        assertEquals(meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.FIRST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.FIRST));
     }
 
     @Ignore
     public void test_first_saturday_of_january_2013() {
         LocalDate expected = LocalDate.of(2013, 1, 5);
         Meetup meetup = new Meetup(1, 2013);
-        assertEquals(meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.FIRST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.FIRST));
     }
 
     @Ignore
     public void test_first_saturday_of_february_2013() {
         LocalDate expected = LocalDate.of(2013, 2, 2);
         Meetup meetup = new Meetup(2, 2013);
-        assertEquals(meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.FIRST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.FIRST));
     }
 
     @Ignore
     public void test_first_sunday_of_march_2013() {
         LocalDate expected = LocalDate.of(2013, 3, 3);
         Meetup meetup = new Meetup(3, 2013);
-        assertEquals(meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.FIRST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.FIRST));
     }
 
     @Ignore
     public void test_first_sunday_of_april_2013() {
         LocalDate expected = LocalDate.of(2013, 4, 7);
         Meetup meetup = new Meetup(4, 2013);
-        assertEquals(meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.FIRST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.FIRST));
     }
 
     @Ignore
     public void test_second_monday_of_march_2013() {
         LocalDate expected = LocalDate.of(2013, 3, 11);
         Meetup meetup = new Meetup(3, 2013);
-        assertEquals(meetup.day(DayOfWeek.MONDAY, MeetupSchedule.SECOND), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.SECOND));
     }
 
     @Ignore
     public void test_second_monday_of_april_2013() {
         LocalDate expected = LocalDate.of(2013, 4, 8);
         Meetup meetup = new Meetup(4, 2013);
-        assertEquals(meetup.day(DayOfWeek.MONDAY, MeetupSchedule.SECOND), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.SECOND));
     }
 
     @Ignore
     public void test_second_tuesday_of_may_2013() {
         LocalDate expected = LocalDate.of(2013, 5, 14);
         Meetup meetup = new Meetup(5, 2013);
-        assertEquals(meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.SECOND), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.SECOND));
     }
 
     @Ignore
     public void test_second_tuesday_of_june_2013() {
         LocalDate expected = LocalDate.of(2013, 6, 11);
         Meetup meetup = new Meetup(6, 2013);
-        assertEquals(meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.SECOND), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.SECOND));
     }
 
     @Ignore
     public void test_second_wednesday_of_july_2013() {
         LocalDate expected = LocalDate.of(2013, 7, 10);
         Meetup meetup = new Meetup(7, 2013);
-        assertEquals(meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.SECOND), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.SECOND));
     }
 
     @Ignore
     public void test_second_wednesday_of_august_2013() {
         LocalDate expected = LocalDate.of(2013, 8, 14);
         Meetup meetup = new Meetup(8, 2013);
-        assertEquals(meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.SECOND), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.SECOND));
     }
 
     @Ignore
     public void test_second_thursday_of_september_2013() {
         LocalDate expected = LocalDate.of(2013, 9, 12);
         Meetup meetup = new Meetup(9, 2013);
-        assertEquals(meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.SECOND), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.SECOND));
     }
 
     @Ignore
     public void test_second_thursday_of_october_2013() {
         LocalDate expected = LocalDate.of(2013, 10, 10);
         Meetup meetup = new Meetup(10, 2013);
-        assertEquals(meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.SECOND), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.SECOND));
     }
 
     @Ignore
     public void test_second_friday_of_november_2013() {
         LocalDate expected = LocalDate.of(2013, 11, 8);
         Meetup meetup = new Meetup(11, 2013);
-        assertEquals(meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.SECOND), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.SECOND));
     }
 
     @Ignore
     public void test_second_friday_of_december_2013() {
         LocalDate expected = LocalDate.of(2013, 12, 13);
         Meetup meetup = new Meetup(12, 2013);
-        assertEquals(meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.SECOND), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.SECOND));
     }
 
     @Ignore
     public void test_second_saturday_of_january_2013() {
         LocalDate expected = LocalDate.of(2013, 1, 12);
         Meetup meetup = new Meetup(1, 2013);
-        assertEquals(meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.SECOND), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.SECOND));
     }
 
     @Ignore
     public void test_second_saturday_of_february_2013() {
         LocalDate expected = LocalDate.of(2013, 2, 9);
         Meetup meetup = new Meetup(2, 2013);
-        assertEquals(meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.SECOND), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.SECOND));
     }
 
     @Ignore
     public void test_second_sunday_of_march_2013() {
         LocalDate expected = LocalDate.of(2013, 3, 10);
         Meetup meetup = new Meetup(3, 2013);
-        assertEquals(meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.SECOND), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.SECOND));
     }
 
     @Ignore
     public void test_second_sunday_of_april_2013() {
         LocalDate expected = LocalDate.of(2013, 4, 14);
         Meetup meetup = new Meetup(4, 2013);
-        assertEquals(meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.SECOND), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.SECOND));
     }
 
     @Ignore
     public void test_third_monday_of_march_2013() {
         LocalDate expected = LocalDate.of(2013, 3, 18);
         Meetup meetup = new Meetup(3, 2013);
-        assertEquals(meetup.day(DayOfWeek.MONDAY, MeetupSchedule.THIRD), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.THIRD));
     }
 
     @Ignore
     public void test_third_monday_of_april_2013() {
         LocalDate expected = LocalDate.of(2013, 4, 15);
         Meetup meetup = new Meetup(4, 2013);
-        assertEquals(meetup.day(DayOfWeek.MONDAY, MeetupSchedule.THIRD), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.THIRD));
     }
 
     @Ignore
     public void test_third_tuesday_of_may_2013() {
         LocalDate expected = LocalDate.of(2013, 5, 21);
         Meetup meetup = new Meetup(5, 2013);
-        assertEquals(meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.THIRD), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.THIRD));
     }
 
     @Ignore
     public void test_third_tuesday_of_june_2013() {
         LocalDate expected = LocalDate.of(2013, 6, 18);
         Meetup meetup = new Meetup(6, 2013);
-        assertEquals(meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.THIRD), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.THIRD));
     }
 
     @Ignore
     public void test_third_wednesday_of_july_2013() {
         LocalDate expected = LocalDate.of(2013, 7, 17);
         Meetup meetup = new Meetup(7, 2013);
-        assertEquals(meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.THIRD), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.THIRD));
     }
 
     @Ignore
     public void test_third_wednesday_of_august_2013() {
         LocalDate expected = LocalDate.of(2013, 8, 21);
         Meetup meetup = new Meetup(8, 2013);
-        assertEquals(meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.THIRD), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.THIRD));
     }
 
     @Ignore
     public void test_third_thursday_of_september_2013() {
         LocalDate expected = LocalDate.of(2013, 9, 19);
         Meetup meetup = new Meetup(9, 2013);
-        assertEquals(meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.THIRD), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.THIRD));
     }
 
     @Ignore
     public void test_third_thursday_of_october_2013() {
         LocalDate expected = LocalDate.of(2013, 10, 17);
         Meetup meetup = new Meetup(10, 2013);
-        assertEquals(meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.THIRD), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.THIRD));
     }
 
     @Ignore
     public void test_third_friday_of_november_2013() {
         LocalDate expected = LocalDate.of(2013, 11, 15);
         Meetup meetup = new Meetup(11, 2013);
-        assertEquals(meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.THIRD), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.THIRD));
     }
 
     @Ignore
     public void test_third_friday_of_december_2013() {
         LocalDate expected = LocalDate.of(2013, 12, 20);
         Meetup meetup = new Meetup(12, 2013);
-        assertEquals(meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.THIRD), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.THIRD));
     }
 
     @Ignore
     public void test_third_saturday_of_january_2013() {
         LocalDate expected = LocalDate.of(2013, 1, 19);
         Meetup meetup = new Meetup(1, 2013);
-        assertEquals(meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.THIRD), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.THIRD));
     }
 
     @Ignore
     public void test_third_saturday_of_february_2013() {
         LocalDate expected = LocalDate.of(2013, 2, 16);
         Meetup meetup = new Meetup(2, 2013);
-        assertEquals(meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.THIRD), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.THIRD));
     }
 
     @Ignore
     public void test_third_sunday_of_march_2013() {
         LocalDate expected = LocalDate.of(2013, 3, 17);
         Meetup meetup = new Meetup(3, 2013);
-        assertEquals(meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.THIRD), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.THIRD));
     }
 
     @Ignore
     public void test_third_sunday_of_april_2013() {
         LocalDate expected = LocalDate.of(2013, 4, 21);
         Meetup meetup = new Meetup(4, 2013);
-        assertEquals(meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.THIRD), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.THIRD));
     }
 
     @Ignore
     public void test_fourth_monday_of_march_2013() {
         LocalDate expected = LocalDate.of(2013, 3, 25);
         Meetup meetup = new Meetup(3, 2013);
-        assertEquals(meetup.day(DayOfWeek.MONDAY, MeetupSchedule.FOURTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.FOURTH));
     }
 
     @Ignore
     public void test_fourth_monday_of_april_2013() {
         LocalDate expected = LocalDate.of(2013, 4, 22);
         Meetup meetup = new Meetup(4, 2013);
-        assertEquals(meetup.day(DayOfWeek.MONDAY, MeetupSchedule.FOURTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.FOURTH));
     }
 
     @Ignore
     public void test_fourth_tuesday_of_may_2013() {
         LocalDate expected = LocalDate.of(2013, 5, 28);
         Meetup meetup = new Meetup(5, 2013);
-        assertEquals(meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.FOURTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.FOURTH));
     }
 
     @Ignore
     public void test_fourth_tuesday_of_june_2013() {
         LocalDate expected = LocalDate.of(2013, 6, 25);
         Meetup meetup = new Meetup(6, 2013);
-        assertEquals(meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.FOURTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.FOURTH));
     }
 
     @Ignore
     public void test_fourth_wednesday_of_july_2013() {
         LocalDate expected = LocalDate.of(2013, 7, 24);
         Meetup meetup = new Meetup(7, 2013);
-        assertEquals(meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.FOURTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.FOURTH));
     }
 
     @Ignore
     public void test_fourth_wednesday_of_august_2013() {
         LocalDate expected = LocalDate.of(2013, 8, 28);
         Meetup meetup = new Meetup(8, 2013);
-        assertEquals(meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.FOURTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.FOURTH));
     }
 
     @Ignore
     public void test_fourth_thursday_of_september_2013() {
         LocalDate expected = LocalDate.of(2013, 9, 26);
         Meetup meetup = new Meetup(9, 2013);
-        assertEquals(meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.FOURTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.FOURTH));
     }
 
     @Ignore
     public void test_fourth_thursday_of_october_2013() {
         LocalDate expected = LocalDate.of(2013, 10, 24);
         Meetup meetup = new Meetup(10, 2013);
-        assertEquals(meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.FOURTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.FOURTH));
     }
 
     @Ignore
     public void test_fourth_friday_of_november_2013() {
         LocalDate expected = LocalDate.of(2013, 11, 22);
         Meetup meetup = new Meetup(11, 2013);
-        assertEquals(meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.FOURTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.FOURTH));
     }
 
     @Ignore
     public void test_fourth_friday_of_december_2013() {
         LocalDate expected = LocalDate.of(2013, 12, 27);
         Meetup meetup = new Meetup(12, 2013);
-        assertEquals(meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.FOURTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.FOURTH));
     }
 
     @Ignore
     public void test_fourth_saturday_of_january_2013() {
         LocalDate expected = LocalDate.of(2013, 1, 26);
         Meetup meetup = new Meetup(1, 2013);
-        assertEquals(meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.FOURTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.FOURTH));
     }
 
     @Ignore
     public void test_fourth_saturday_of_february_2013() {
         LocalDate expected = LocalDate.of(2013, 2, 23);
         Meetup meetup = new Meetup(2, 2013);
-        assertEquals(meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.FOURTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.FOURTH));
     }
 
     @Ignore
     public void test_fourth_sunday_of_march_2013() {
         LocalDate expected = LocalDate.of(2013, 3, 24);
         Meetup meetup = new Meetup(3, 2013);
-        assertEquals(meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.FOURTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.FOURTH));
     }
 
     @Ignore
     public void test_fourth_sunday_of_april_2013() {
         LocalDate expected = LocalDate.of(2013, 4, 28);
         Meetup meetup = new Meetup(4, 2013);
-        assertEquals(meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.FOURTH), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.FOURTH));
     }
 
     @Ignore
     public void test_last_monday_of_march_2013() {
         LocalDate expected = LocalDate.of(2013, 3, 25);
         Meetup meetup = new Meetup(3, 2013);
-        assertEquals(meetup.day(DayOfWeek.MONDAY, MeetupSchedule.LAST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.LAST));
     }
 
     @Ignore
     public void test_last_monday_of_april_2013() {
         LocalDate expected = LocalDate.of(2013, 4, 29);
         Meetup meetup = new Meetup(4, 2013);
-        assertEquals(meetup.day(DayOfWeek.MONDAY, MeetupSchedule.LAST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.LAST));
     }
 
     @Ignore
     public void test_last_tuesday_of_may_2013() {
         LocalDate expected = LocalDate.of(2013, 5, 28);
         Meetup meetup = new Meetup(5, 2013);
-        assertEquals(meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.LAST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.LAST));
     }
 
     @Ignore
     public void test_last_tuesday_of_june_2013() {
         LocalDate expected = LocalDate.of(2013, 6, 25);
         Meetup meetup = new Meetup(6, 2013);
-        assertEquals(meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.LAST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.LAST));
     }
 
     @Ignore
     public void test_last_wednesday_of_july_2013() {
         LocalDate expected = LocalDate.of(2013, 7, 31);
         Meetup meetup = new Meetup(7, 2013);
-        assertEquals(meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.LAST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.LAST));
     }
 
     @Ignore
     public void test_last_wednesday_of_august_2013() {
         LocalDate expected = LocalDate.of(2013, 8, 28);
         Meetup meetup = new Meetup(8, 2013);
-        assertEquals(meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.LAST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.LAST));
     }
 
     @Ignore
     public void test_last_thursday_of_september_2013() {
         LocalDate expected = LocalDate.of(2013, 9, 26);
         Meetup meetup = new Meetup(9, 2013);
-        assertEquals(meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.LAST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.LAST));
     }
 
     @Ignore
     public void test_last_thursday_of_october_2013() {
         LocalDate expected = LocalDate.of(2013, 10, 31);
         Meetup meetup = new Meetup(10, 2013);
-        assertEquals(meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.LAST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.LAST));
     }
 
     @Ignore
     public void test_last_friday_of_november_2013() {
         LocalDate expected = LocalDate.of(2013, 11, 29);
         Meetup meetup = new Meetup(11, 2013);
-        assertEquals(meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.LAST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.LAST));
     }
 
     @Ignore
     public void test_last_friday_of_december_2013() {
         LocalDate expected = LocalDate.of(2013, 12, 27);
         Meetup meetup = new Meetup(12, 2013);
-        assertEquals(meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.LAST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.LAST));
     }
 
     @Ignore
     public void test_last_saturday_of_january_2013() {
         LocalDate expected = LocalDate.of(2013, 1, 26);
         Meetup meetup = new Meetup(1, 2013);
-        assertEquals(meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.LAST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.LAST));
     }
 
     @Ignore
     public void test_last_saturday_of_february_2013() {
         LocalDate expected = LocalDate.of(2013, 2, 23);
         Meetup meetup = new Meetup(2, 2013);
-        assertEquals(meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.LAST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.LAST));
     }
 
     @Ignore
     public void test_last_sunday_of_march_2013() {
         LocalDate expected = LocalDate.of(2013, 3, 31);
         Meetup meetup = new Meetup(3, 2013);
-        assertEquals(meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.LAST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.LAST));
     }
 
     @Ignore
     public void test_last_sunday_of_april_2013() {
         LocalDate expected = LocalDate.of(2013, 4, 28);
         Meetup meetup = new Meetup(4, 2013);
-        assertEquals(meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.LAST), expected);
+        assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.LAST));
     }
 }

exercises/queen-attack/src/test/java/QueenAttackCalculatorTest.java

     public ExpectedException expectedException = ExpectedException.none();
 
     @Test
-    public void testCoordinateWithNegativeRankNotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have positive rank.");
+    public void testQueensThatDoNotShareRankFileOrDiagonalCannotAttack() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new BoardCoordinate(2, 4), new BoardCoordinate(6, 6));
 
-        new BoardCoordinate(-2, 2);
+        assertFalse(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore
     @Test
-    public void testCoordinateWithRankGreaterThan7NotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have rank <= 7.");
+    public void testQueensCanAttackOnTheSameRank() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new BoardCoordinate(2, 4), new BoardCoordinate(2, 6));
 
-        new BoardCoordinate(8, 4);
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore
     @Test
-    public void testCoordinateWithNegativeFileNotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have positive file.");
+    public void testQueensCanAttackOnTheSameFile() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new BoardCoordinate(4, 5), new BoardCoordinate(2, 5));
 
-        new BoardCoordinate(2, -2);
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore
     @Test
-    public void testCoordinateWithFileGreaterThan7NotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have file <= 7.");
+    public void testQueensCanAttackOnFirstDiagonal() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(0, 4));
 
-        new BoardCoordinate(4, 8);
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore
     @Test
-    public void testNullCoordinateNotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("You must supply valid board coordinates for both Queens.");
+    public void testQueensCanAttackOnSecondDiagonal() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(3, 1));
 
-        new QueenAttackCalculator(null, new BoardCoordinate(0, 7));
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore
     @Test
-    public void testQueensMustNotOccupyTheSameSquare() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Queens may not occupy the same board coordinate.");
+    public void testQueensCanAttackOnThirdDiagonal() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(1, 1));
 
-        new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(2, 2));
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore
     @Test
-    public void testQueensThatDoNotShareRankFileOrDiagonalCannotAttack() {
+    public void testQueensCanAttackOnFourthDiagonal() {
         final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 4), new BoardCoordinate(6, 6));
+                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(5, 5));
 
-        assertFalse(calculator.canQueensAttackOneAnother());
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore
     @Test
-    public void testQueensCanAttackOnTheSameRank() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 4), new BoardCoordinate(2, 6));
+    public void testCoordinateWithNegativeRankNotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Coordinate must have positive rank.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new BoardCoordinate(-2, 2);
     }
 
     @Ignore
     @Test
-    public void testQueensCanAttackOnTheSameFile() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(4, 5), new BoardCoordinate(2, 5));
+    public void testCoordinateWithRankGreaterThan7NotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Coordinate must have rank <= 7.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new BoardCoordinate(8, 4);
     }
 
     @Ignore
     @Test
-    public void testQueensCanAttackOnFirstDiagonal() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(0, 4));
+    public void testCoordinateWithNegativeFileNotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Coordinate must have positive file.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new BoardCoordinate(2, -2);
     }
 
     @Ignore
     @Test
-    public void testQueensCanAttackOnSecondDiagonal() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(3, 1));
+    public void testCoordinateWithFileGreaterThan7NotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Coordinate must have file <= 7.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new BoardCoordinate(4, 8);
     }
 
     @Ignore
     @Test
-    public void testQueensCanAttackOnThirdDiagonal() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(1, 1));
+    public void testNullCoordinateNotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("You must supply valid board coordinates for both Queens.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new QueenAttackCalculator(null, new BoardCoordinate(0, 7));
     }
 
     @Ignore
     @Test
-    public void testQueensCanAttackOnFourthDiagonal() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(5, 5));
+    public void testQueensMustNotOccupyTheSameSquare() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queens may not occupy the same board coordinate.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(2, 2));
     }
 
 }

exercises/rectangles/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/rectangles/src/example/java/RectangleCounter.java

+import static java.util.Arrays.copyOfRange;
+import static java.util.Arrays.stream;
+
+final class RectangleCounter {
+
+    int countRectangles(final String[] rawGrid) {
+        final int nRows = rawGrid.length;
+        if (nRows == 0) return 0;
+
+        final int nCols = rawGrid[0].length();
+        if (nCols == 0) return 0;
+
+        return new Grid(nRows, nCols, rawGrid).countRectangles();
+    }
+
+    private static final class Grid {
+
+        private enum Entry {
+            CORNER,
+            HLINE,
+            VLINE,
+            SPACE;
+
+            private static Entry fromChar(final char rawGridEntry) {
+                switch (rawGridEntry) {
+                    case '+': return CORNER;
+                    case '-': return HLINE;
+                    case '|': return VLINE;
+                    case ' ': return SPACE;
+                    default:  throw new IllegalStateException("Grid entry " + rawGridEntry + " not recognized.");
+                }
+            }
+        }
+
+        private int nRows, nCols;
+        private final Entry[][] entries;
+
+        private Grid(final int nRows, final int nCols, final String[] rawGrid) {
+            this.nRows = nRows;
+            this.nCols = nCols;
+            this.entries = new Entry[nRows][nCols];
+
+            for (int nRow = 0; nRow < nRows; nRow++) {
+                for (int nCol = 0; nCol < nCols; nCol++) {
+                    entries[nRow][nCol] = Entry.fromChar(rawGrid[nRow].charAt(nCol));
+                }
+            }
+        }
+
+        private int countRectangles() {
+            int result = 0;
+
+            for (int topRow = 0; topRow < nRows - 1; topRow++) {
+
+                for (int leftCol = 0; leftCol < nCols - 1; leftCol++) {
+
+                    // Only check rectangles that lie below/to the right of our current coordinate:
+                    for (int bottomRow = topRow + 1; bottomRow < nRows; bottomRow++) {
+
+                        for (int rightCol = leftCol + 1; rightCol < nCols; rightCol++) {
+
+                            if (formsRectangle(topRow, bottomRow, leftCol, rightCol)) {
+                                result++;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        private boolean formsRectangle(
+                final int topRow,
+                final int bottomRow,
+                final int leftCol,
+                final int rightCol) {
+
+            return entries[topRow][leftCol].equals(Entry.CORNER)
+                    && entries[topRow][rightCol].equals(Entry.CORNER)
+                    && entries[bottomRow][leftCol].equals(Entry.CORNER)
+                    && entries[bottomRow][rightCol].equals(Entry.CORNER)
+                    && isHorizontalLineSegment(topRow, leftCol, rightCol)
+                    && isHorizontalLineSegment(bottomRow, leftCol, rightCol)
+                    && isVerticalLineSegment(leftCol, topRow, bottomRow)
+                    && isVerticalLineSegment(rightCol, topRow, bottomRow);
+        }
+
+        private boolean isHorizontalLineSegment(final int row, final int leftCol, final int rightCol) {
+            return stream(copyOfRange(getRow(row), leftCol, rightCol))
+                    .allMatch(entry -> entry.equals(Entry.HLINE) || entry.equals(Entry.CORNER));
+        }
+
+        private boolean isVerticalLineSegment(final int col, final int topRow, final int bottomRow) {
+            return stream(copyOfRange(getCol(col), topRow, bottomRow))
+                    .allMatch(entry -> entry.equals(Entry.VLINE) || entry.equals(Entry.CORNER));
+        }
+
+        private Entry[] getRow(final int number) {
+            return entries[number];
+        }
+
+        private Entry[] getCol(final int number) {
+            final Entry[] result = new Entry[nRows];
+
+            for (int nRow = 0; nRow < nRows; nRow++) {
+                result[nRow] = entries[nRow][number];
+            }
+
+            return result;
+        }
+
+    }
+
+}

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

+final class RectangleCounter {
+
+
+
+}

exercises/rectangles/src/test/java/RectangleCounterTest.java

+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public final class RectangleCounterTest {
+
+    private RectangleCounter rectangleCounter;
+
+    @Before
+    public void setUp() {
+        rectangleCounter = new RectangleCounter();
+    }
+
+    @Test
+    public void testInputWithNoColumnsContainsNoRectangles() {
+        String[] inputGrid = new String[]{};
+
+        assertEquals(0, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testNonTrivialInputWithNoRectangles() {
+        String[] inputGrid = new String[]{" "};
+
+        assertEquals(0, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testInputWithOneRectangle() {
+        String[] inputGrid = new String[]{
+                "+-+",
+                "| |",
+                "+-+"
+        };
+
+        assertEquals(1, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testInputWithTwoRectanglesWithoutSharedEdges() {
+        String[] inputGrid = new String[]{
+                "  +-+",
+                "  | |",
+                "+-+-+",
+                "| |  ",
+                "+-+  "
+        };
+
+        assertEquals(2, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testInputWithFiveRectanglesWithSharedEdges() {
+        String[] inputGrid = new String[]{
+                "  +-+",
+                "  | |",
+                "+-+-+",
+                "| | |",
+                "+-+-+"
+        };
+
+        assertEquals(5, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testThatRectangleOfHeightOneIsCounted() {
+        String[] inputGrid = new String[]{
+                "+--+",
+                "+--+"
+        };
+
+        assertEquals(1, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testThatRectangleOfWidthOneIsCounted() {
+        String[] inputGrid = new String[]{
+                "++",
+                "||",
+                "++"
+        };
+
+        assertEquals(1, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testThatOneByOneSquareIsCounted() {
+        String[] inputGrid = new String[]{
+                "++",
+                "++"
+        };
+
+        assertEquals(1, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testThatIncompleteRectanglesAreNotCounted() {
+        String[] inputGrid = new String[]{
+                "  +-+",
+                "    |",
+                "+-+-+",
+                "| | -",
+                "+-+-+"
+        };
+
+        assertEquals(1, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testThatRectanglesOfDifferentSizesAreAllCounted() {
+        String[] inputGrid = new String[]{
+                "+------+----+",
+                "|      |    |",
+                "+---+--+    |",
+                "|   |       |",
+                "+---+-------+"
+        };
+
+        assertEquals(3, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testThatIntersectionsWithoutCornerCharacterDoNotCountAsRectangleCorners() {
+        String[] inputGrid = new String[]{
+                "+------+----+",
+                "|      |    |",
+                "+------+    |",
+                "|   |       |",
+                "+---+-------+"
+        };
+
+        assertEquals(2, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testLargeInputWithManyRectangles() {
+        String[] inputGrid = new String[]{
+                "+---+--+----+",
+                "|   +--+----+",
+                "+---+--+    |",
+                "|   +--+----+",
+                "+---+--+--+-+",
+                "+---+--+--+-+",
+                "+------+  | |",
+                "          +-+"
+        };
+
+        assertEquals(60, rectangleCounter.countRectangles(inputGrid));
+    }
+
+}

exercises/settings.gradle

 include 'atbash-cipher'
 include 'beer-song'
 include 'binary'
+include 'binary-search'
 include 'binary-search-tree'
 include 'bob'
 include 'bracket-push'
 include 'pig-latin'
 include 'queen-attack'
 include 'raindrops'
+include 'rectangles'
 include 'rna-transcription'
 include 'robot-name'
 include 'robot-simulator'

exercises/word-count/src/test/java/WordCountTest.java

+import org.junit.Before;
 import org.junit.Test;
 import org.junit.Ignore;
 
 
 public class WordCountTest {
 
-    private final WordCount wordCount = new WordCount();
+    private WordCount wordCount;
+    private Map<String, Integer> actualWordCount;
+    private Map<String, Integer> expectedWordCount;
+
+    @Before
+    public void setup() {
+        wordCount = new WordCount();
+        expectedWordCount = new HashMap<String, Integer>();
+    }
 
 
     @Test
     public void countOneWord() {
-        Map<String, Integer> actualWordCount = new HashMap<String, Integer>();
-        final Map<String, Integer> expectedWordCount = new HashMap<String, Integer>();
         expectedWordCount.put("word", 1);
 
         actualWordCount = wordCount.phrase("word");
     @Ignore
     @Test
     public void countOneOfEach() {
-        Map<String, Integer> actualWordCount = new HashMap<String, Integer>();
-        final Map<String, Integer> expectedWordCount = new HashMap<String, Integer>();
         expectedWordCount.put("one", 1);
         expectedWordCount.put("of", 1);
         expectedWordCount.put("each", 1);
     @Ignore
     @Test
     public void countMultipleOccurences() {
-        Map<String, Integer> actualWordCount = new HashMap<String, Integer>();
-        final Map<String, Integer> expectedWordCount = new HashMap<String, Integer>();
         expectedWordCount.put("one", 1);
         expectedWordCount.put("fish", 4);
         expectedWordCount.put("two", 1);
     @Ignore
     @Test
     public void ignorePunctuation() {
-        Map<String, Integer> actualWordCount = new HashMap<String, Integer>();
-        final Map<String, Integer> expectedWordCount = new HashMap<String, Integer>();
         expectedWordCount.put("car", 1);
         expectedWordCount.put("carpet", 1);
         expectedWordCount.put("as", 1);
     @Ignore
     @Test
     public void includeNumbers() {
-        Map<String, Integer> actualWordCount = new HashMap<String, Integer>();
-        final Map<String, Integer> expectedWordCount = new HashMap<String, Integer>();
         expectedWordCount.put("testing", 2);
         expectedWordCount.put("1", 1);
         expectedWordCount.put("2", 1);
     @Ignore
     @Test
     public void normalizeCase() {
-        Map<String, Integer> actualWordCount = new HashMap<String, Integer>();
-        final Map<String, Integer> expectedWordCount = new HashMap<String, Integer>();
         expectedWordCount.put("go", 3);
 
         actualWordCount = wordCount.phrase("go Go GO");