Merge branch 'exercism/master'

config.json

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

exercises/matrix/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/matrix/src/example/java/Matrix.java

+import java.util.regex.Pattern;
+
+public class Matrix {
+    private int[][] matrix;
+    private static Pattern spacePattern = Pattern.compile(" ");
+    private static Pattern newlinePattern = Pattern.compile("\\n");
+
+    public Matrix(String matrixAsString) {
+        String[] rows = newlinePattern.split(matrixAsString);
+        matrix = new int[rows.length][];
+        for (int i = 0; i < rows.length; i++) {
+            String[] columnValues = spacePattern.split(rows[i]);
+            matrix[i] = new int[columnValues.length];
+            for (int j = 0; j < columnValues.length; j++) {
+                matrix[i][j] = Integer.parseInt(columnValues[j]);
+            }
+        }
+    }
+
+    public int[] getRow(int rowNumber) {
+        return matrix[rowNumber];
+    }
+
+    public int[] getColumn(int columnNumber) {
+        int[] column = new int[matrix.length];
+        for(int i = 0; i < matrix.length; i++) {
+            column[i] = matrix[i][columnNumber];
+        }
+        return column;
+    }
+
+    public int getRowsCount() {
+        return matrix.length;
+    }
+
+    public int getColumnsCount() {
+        return matrix[0].length;
+    }
+}

exercises/matrix/src/test/java/MatrixTest.java

+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+@RunWith(Enclosed.class)
+public class MatrixTest {
+
+    @RunWith(Parameterized.class)
+    public static class CountRowsTest {
+        private Matrix matrix;
+        private int numberOfRows;
+
+        @Parameterized.Parameters(name = "{index}: expected matrix constructed with string \n\"{0}\" to have {1} row(s).")
+        public static Collection<Object[]> data() {
+            return Arrays.asList(new Object[][]{
+                    {"0", 1},
+                    {"0 1", 1},
+                    {  "0\n"
+                     + "1", 2},
+                    {  "0 1\n"
+                     + "2 3", 2},
+                    {  "0 1 2\n"
+                     + "3 4 5\n"
+                     + "6 7 8", 3}
+            });
+        }
+
+        public CountRowsTest(String matrixAsString, int numberOfRows) {
+            this.matrix = new Matrix(matrixAsString);
+            this.numberOfRows = numberOfRows;
+        }
+
+        @Test
+        public void countRowsTest() {
+            assertEquals(numberOfRows, matrix.getRowsCount());
+        }
+    }
+
+    @Ignore
+    @RunWith(Parameterized.class)
+    public static class CountColumnsTest {
+        private Matrix matrix;
+        private int numberOfColumns;
+
+        @Parameterized.Parameters(name = "{index}: expected matrix constructed with string \n\"{0}\" to have {1} column(s).")
+        public static Collection<Object[]> data() {
+            return Arrays.asList(new Object[][]{
+                    {"0", 1},
+                    {"0 1", 2},
+                    {  "0\n"
+                     + "1", 1},
+                    {  "0 1\n"
+                     + "2 3", 2},
+                    {  "0 1 2\n"
+                     + "3 4 5\n"
+                     + "6 7 8", 3}
+            });
+        }
+
+        public CountColumnsTest(String matrixAsString, int numberOfColumns) {
+            this.matrix = new Matrix(matrixAsString);
+            this.numberOfColumns = numberOfColumns;
+        }
+
+        @Test
+        public void countColumnsTest() {
+            assertEquals(numberOfColumns, matrix.getColumnsCount());
+        }
+    }
+
+    @Ignore
+    @RunWith(Parameterized.class)
+    public static class GetFirstRowTest {
+        private Matrix matrix;
+        private int[] firstRow;
+
+        @Parameterized.Parameters(name = "{index}: checking first row of matrix constructed with string \n\"{0}\".")
+        public static Collection<Object[]> data() {
+            return Arrays.asList(new Object[][]{
+                    {"0", new int[] {0}},
+                    {"0 1", new int[] {0, 1}},
+                    {  "0\n"
+                     + "1", new int[] {0}},
+                    {  "0 1\n"
+                     + "2 3", new int[] {0, 1}},
+                    {  "0 1 2\n"
+                     + "3 4 5\n"
+                     + "6 7 8", new int[] {0, 1, 2}}
+            });
+        }
+
+        public GetFirstRowTest(String matrixAsString, int[] firstRow) {
+            this.matrix = new Matrix(matrixAsString);
+            this.firstRow = firstRow;
+        }
+
+        @Test
+        public void getFirstRowTest() {
+            assertArrayEquals(firstRow, matrix.getRow(0));
+        }
+    }
+
+    @Ignore
+    @RunWith(Parameterized.class)
+    public static class GetLastRowTest {
+        private Matrix matrix;
+        private int[] lastRow;
+
+        @Parameterized.Parameters(name = "{index}: checking last row of matrix constructed with string \n\"{0}\".")
+        public static Collection<Object[]> data() {
+            return Arrays.asList(new Object[][]{
+                    {"0", new int[] {0}},
+                    {"0 1", new int[] {0, 1}},
+                    {  "0\n"
+                     + "1", new int[] {1}},
+                    {  "0 1\n"
+                     + "2 3", new int[] {2, 3}},
+                    {  "0 1 2\n"
+                     + "3 4 5\n"
+                     + "6 7 8", new int[] {6, 7, 8}}
+            });
+        }
+
+        public GetLastRowTest(String matrixAsString, int[] lastRow) {
+            this.matrix = new Matrix(matrixAsString);
+            this.lastRow = lastRow;
+        }
+
+        @Test
+        public void getLastRowTest() {
+            assertArrayEquals(lastRow, matrix.getRow(matrix.getRowsCount() - 1));
+        }
+    }
+
+    @Ignore
+    @RunWith(Parameterized.class)
+    public static class GetFirstColumnTest {
+        private Matrix matrix;
+        private int[] firstColumn;
+
+        @Parameterized.Parameters(name = "{index}: checking first column of matrix constructed with string \n\"{0}\".")
+        public static Collection<Object[]> data() {
+            return Arrays.asList(new Object[][]{
+                    {"0", new int[] {0}},
+                    {"0 1", new int[] {0}},
+                    {  "0\n"
+                     + "1", new int[] {0, 1}},
+                    {  "0 1\n"
+                     + "2 3", new int[] {0, 2}},
+                    {  "0 1 2\n"
+                     + "3 4 5\n"
+                     + "6 7 8", new int[] {0, 3, 6}}
+            });
+        }
+
+        public GetFirstColumnTest(String matrixAsString, int[] firstColumn) {
+            this.matrix = new Matrix(matrixAsString);
+            this.firstColumn = firstColumn;
+        }
+
+        @Test
+        public void getFirstColumnTest() {
+            assertArrayEquals(firstColumn, matrix.getColumn(0));
+        }
+    }
+
+
+    @Ignore
+    @RunWith(Parameterized.class)
+    public static class GetLastColumnTest {
+        private Matrix matrix;
+        private int[] lastColumn;
+
+        @Parameterized.Parameters(name = "{index}: checking last column of matrix constructed with string \n\"{0}\".")
+        public static Collection<Object[]> data() {
+            return Arrays.asList(new Object[][]{
+                    {"0", new int[] {0}},
+                    {"0 1", new int[] {1}},
+                    {  "0\n"
+                     + "1", new int[] {0, 1}},
+                    {  "0 1\n"
+                     + "2 3", new int[] {1, 3}},
+                    {  "0 1 2\n"
+                     + "3 4 5\n"
+                     + "6 7 8", new int[] {2, 5, 8}}
+            });
+        }
+
+        public GetLastColumnTest(String matrixAsString, int[] lastColumn) {
+            this.matrix = new Matrix(matrixAsString);
+            this.lastColumn = lastColumn;
+        }
+
+        @Test
+        public void getLastColumnTest() {
+            assertArrayEquals(lastColumn, matrix.getColumn(matrix.getColumnsCount() - 1));
+        }
+    }
+}

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/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 'pig-latin'
 include 'queen-attack'
 include 'raindrops'
+include 'rectangles'
 include 'rna-transcription'
 include 'robot-name'
 include 'robot-simulator'
 include 'word-count'
 include 'wordy'
 include 'twelve-days'
-
+include 'matrix'