trackler 2.2.1.86 → 2.2.1.87

data/tracks/idris/config.json

@@ -51,7 +51,7 @@
         "map"
       ],
       "unlocked_by": null,
-      "uuid": "612f5f98-09a6-9d80-5820-edeec5ce1e1544073ed"
+      "uuid": "06242da7-4796-482a-a467-358b22128c32"
     }
   ],
   "foregone": [],
@@ -61,4 +61,4 @@
     "docs"
   ],
   "language": "Idris"
-}
+}

data/tracks/java/exercises/all-your-base/.meta/src/reference/java/BaseConverter.java

@@ -39,11 +39,7 @@ final class BaseConverter {
         }
 
         if (originalDigits.length == 0) {
-            throw new IllegalArgumentException("You must supply at least one digit.");
-        }
-
-        if (originalDigits.length > 1 && originalDigits[0] == 0) {
-            throw new IllegalArgumentException("Digits may not contain leading zeros.");
+            return;
         }
 
         if (Arrays.stream(originalDigits).min().getAsInt() < 0) {

data/tracks/java/exercises/all-your-base/.meta/version

@@ -1 +1 @@
-1.1.0
+2.1.0

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

@@ -150,10 +150,18 @@ public class BaseConverterTest {
     @Ignore("Remove to run test")
     @Test
     public void testEmptyDigits() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("You must supply at least one digit.");
+        final BaseConverter baseConverter = new BaseConverter(2, new int[]{});
+
+        final int[] expectedDigits = new int[]{0};
+        final int[] actualDigits = baseConverter.convertToBase(10);
 
-        new BaseConverter(2, new int[]{});
+        assertArrayEquals(
+            String.format(
+                "Expected digits: %s but found digits: %s",
+                Arrays.toString(expectedDigits),
+                Arrays.toString(actualDigits)),
+            expectedDigits,
+            actualDigits);
     }
 
     @Ignore("Remove to run test")
@@ -176,19 +184,35 @@ public class BaseConverterTest {
     @Ignore("Remove to run test")
     @Test
     public void testMultipleZeros() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Digits may not contain leading zeros.");
+        final BaseConverter baseConverter = new BaseConverter(10, new int[]{0, 0, 0});
+
+        final int[] expectedDigits = new int[]{0};
+        final int[] actualDigits = baseConverter.convertToBase(2);
 
-        new BaseConverter(10, new int[]{0, 0, 0});
+        assertArrayEquals(
+            String.format(
+                "Expected digits: %s but found digits: %s",
+                Arrays.toString(expectedDigits),
+                Arrays.toString(actualDigits)),
+            expectedDigits,
+            actualDigits);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testLeadingZeros() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Digits may not contain leading zeros.");
+        final BaseConverter baseConverter = new BaseConverter(7, new int[]{0, 6, 0});
+
+        final int[] expectedDigits = new int[]{4, 2};
+        final int[] actualDigits = baseConverter.convertToBase(10);
 
-        new BaseConverter(7, new int[]{0, 6, 0});
+        assertArrayEquals(
+            String.format(
+                "Expected digits: %s but found digits: %s",
+                Arrays.toString(expectedDigits),
+                Arrays.toString(actualDigits)),
+            expectedDigits,
+            actualDigits);
     }
 
     @Ignore("Remove to run test")
@@ -250,7 +274,7 @@ public class BaseConverterTest {
     @Ignore("Remove to run test")
     @Test
     public void testSecondBaseIsZero() {
-        final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
+        final BaseConverter baseConverter = new BaseConverter(10, new int[]{7});
 
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("Bases must be at least 2.");

data/tracks/java/exercises/bob/README.md

@@ -6,6 +6,8 @@ Bob answers 'Sure.' if you ask him a question.
 
 He answers 'Whoa, chill out!' if you yell at him.
 
+He answers 'Calm down, I know what I'm doing!' if you yell a question at him.
+
 He says 'Fine. Be that way!' if you address him without actually saying
 anything.
 

data/tracks/java/exercises/kindergarten-garden/.meta/version

@@ -0,0 +1 @@
+1.0.0

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

@@ -124,59 +124,4 @@ public class KindergartenGardenTest {
         );
     }
 
-    @Ignore("Remove to run test")
-    @Test
-    public void customStudentGardenFirstStudentInAlphabeticalOrder() {
-        String[] studentArray = {"Samantha", "Patricia", "Xander", "Roger"};
-        String student = "Patricia";
-        String plants = "VCRRGVRG\nRVGCCGCV";
-        List<Plant> expected = Arrays.asList(Plant.VIOLETS, Plant.CLOVER, Plant.RADISHES, Plant.VIOLETS);
-
-        assertEquals(
-            expected,
-            new KindergartenGarden(plants, studentArray).getPlantsOfStudent(student)
-        );
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void customStudentGardenSecondStudentInAlphabeticalOrder() {
-        String[] studentArray = {"Samantha", "Patricia", "Xander", "Roger"};
-        String student = "Roger";
-        String plants = "VCRRGVRG\nRVGCCGCV";
-        List<Plant> expected = Arrays.asList(Plant.RADISHES, Plant.RADISHES, Plant.GRASS, Plant.CLOVER);
-
-        assertEquals(
-            expected,
-            new KindergartenGarden(plants, studentArray).getPlantsOfStudent(student)
-        );
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void customStudentGardenThirdStudentInAlphabeticalOrder() {
-        String[] studentArray = {"Samantha", "Patricia", "Xander", "Roger"};
-        String student = "Samantha";
-        String plants = "VCRRGVRG\nRVGCCGCV";
-        List<Plant> expected = Arrays.asList(Plant.GRASS, Plant.VIOLETS, Plant.CLOVER, Plant.GRASS);
-
-        assertEquals(
-            expected,
-            new KindergartenGarden(plants, studentArray).getPlantsOfStudent(student)
-        );
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void customStudentGardenFourthStudentInAlphabeticalOrder() {
-        String[] studentArray = {"Samantha", "Patricia", "Xander", "Roger"};
-        String student = "Xander";
-        String plants = "VCRRGVRG\nRVGCCGCV";
-        List<Plant> expected = Arrays.asList(Plant.RADISHES, Plant.GRASS, Plant.CLOVER, Plant.VIOLETS);
-
-        assertEquals(
-            expected,
-            new KindergartenGarden(plants, studentArray).getPlantsOfStudent(student)
-        );
-    }
 }

data/tracks/java/exercises/meetup/.meta/version

@@ -0,0 +1 @@
+1.1.0

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

@@ -734,4 +734,36 @@ public class MeetupTest {
         Meetup meetup = new Meetup(4, 2013);
         assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.LAST));
     }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testLastWednesdayOfFebruary2012() {
+        LocalDate expected = LocalDate.of(2012, 2, 29);
+        Meetup meetup = new Meetup(2, 2012);
+        assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.LAST));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testLastWednesdayOfDecember2014() {
+        LocalDate expected = LocalDate.of(2014, 12, 31);
+        Meetup meetup = new Meetup(12, 2014);
+        assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.LAST));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testLastSundayOfFebruary2015() {
+        LocalDate expected = LocalDate.of(2015, 2, 22);
+        Meetup meetup = new Meetup(2, 2015);
+        assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.LAST));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testFirstFridayOfDecember2012() {
+        LocalDate expected = LocalDate.of(2012, 12, 7);
+        Meetup meetup = new Meetup(12, 2012);
+        assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.FIRST));
+    }
 }

data/tracks/java/exercises/parallel-letter-frequency/README.md

@@ -15,6 +15,7 @@ Java documentation on [parallel streams](https://docs.oracle.com/javase/tutorial
 
 As a stretch goal, consider if your implementation will work for characters with [diacritics or accents](https://en.wikipedia.org/wiki/Diacritic). For example, such solutions should not consider e and ë the same character. An example text for this case is [Wilhelmus](https://en.wikipedia.org/wiki/Wilhelmus), the Dutch national anthem.
 
+
 # Running the tests
 
 You can run all the tests for an exercise by entering

data/tracks/java/exercises/proverb/README.md

@@ -1,14 +1,20 @@
-# Proverb in Java
+# Proverb
 
-For want of a horseshoe nail, a kingdom was lost, or so the saying goes. Dynamically output the full test of this proverbial rhyme.
+For want of a horseshoe nail, a kingdom was lost, or so the saying goes.
 
-> For want of a nail the shoe was lost.<br>
-> For want of a shoe the horse was lost.<br>
-> For want of a horse the rider was lost.<br>
-> For want of a rider the message was lost.<br>
-> For want of a message the battle was lost.<br>
-> For want of a battle the kingdom was lost.<br>
-> And all for the want of a horseshoe nail.<br>
+Given a list of inputs, generate the relevant proverb. For example, given the list `["nail", "shoe", "horse", "rider", "message", "battle", "kingdom"]`, you will output the full text of this proverbial rhyme:
+
+```text
+For want of a nail the shoe was lost.
+For want of a shoe the horse was lost.
+For want of a horse the rider was lost.
+For want of a rider the message was lost.
+For want of a message the battle was lost.
+For want of a battle the kingdom was lost.
+And all for the want of a nail.
+```
+
+Note that the list of inputs may vary; your solution should be able to handle lists of arbitrary length and content. No line of the output text should be a static, unchanging string; all should vary according to the input given.
 
 # Running the tests
 
@@ -22,7 +28,7 @@ in your terminal.
 
 ## Source
 
-Wikipedia [https://en.wikipedia.org/wiki/For_Want_of_a_Nail](https://en.wikipedia.org/wiki/For_Want_of_a_Nail)
+Wikipedia [http://en.wikipedia.org/wiki/For_Want_of_a_Nail](http://en.wikipedia.org/wiki/For_Want_of_a_Nail)
 
 ## Submitting Incomplete Solutions
 

data/tracks/java/exercises/rail-fence-cipher/README.md

@@ -58,21 +58,20 @@ W . . . E . . . C . . . R . . . L . . . T . . . E
 
 If you now read along the zig-zag shape you can read the original message.
 
+# Running the tests
 
-
-To run the tests:
+You can run all the tests for an exercise by entering
 
 ```sh
 $ gradle test
 ```
 
-For more detailed info about the Java track see the [help page](http://exercism.io/languages/java).
-
+in your terminal.
 
 ## Source
 
-[Wikipedia](https://en.wikipedia.org/wiki/Transposition_cipher#Rail_Fence_cipher)
+Wikipedia [https://en.wikipedia.org/wiki/Transposition_cipher#Rail_Fence_cipher](https://en.wikipedia.org/wiki/Transposition_cipher#Rail_Fence_cipher)
 
 ## Submitting Incomplete Solutions
+
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.
-i

data/tracks/java/exercises/two-fer/README.md

@@ -66,7 +66,7 @@ in your terminal.
 
 ## Source
 
-This is an exercise to introduce users to basic programming constructs, just after hello World. [https://en.wikipedia.org/wiki/Two-fer](https://en.wikipedia.org/wiki/Two-fer)
+This is an exercise to introduce users to basic programming constructs, just after Hello World. [https://en.wikipedia.org/wiki/Two-fer](https://en.wikipedia.org/wiki/Two-fer)
 
 ## Submitting Incomplete Solutions
 

data/tracks/java/exercises/word-search/.meta/version

@@ -1 +1 @@
-1.0.0
+1.1.0

data/tracks/java/exercises/word-search/src/test/java/WordSearcherTest.java

@@ -1,5 +1,6 @@
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.Ignore;
 
 import java.util.*;
 
@@ -15,7 +16,136 @@ public class WordSearcherTest {
     }
 
     @Test
-    public void testLocatesWordsWrittenLeftToRight() {
+    public void testAcceptsInitialGridAndTargetWord() {
+        Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();
+        expectedLocations.put("clojure", Optional.empty());
+
+        Set<String> searchWords = expectedLocations.keySet();
+
+        Map<String, Optional<WordLocation>> actualLocations = wordSearcher.search(
+                searchWords,
+                new char[][]{
+                        {'j', 'e', 'f', 'b', 'l', 'p', 'e', 'p', 'r', 'e'}
+                }
+        );
+
+        assertEquals(expectedLocations, actualLocations);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testLocatesOneWordWrittenLeftToRight() {
+        Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();
+        expectedLocations.put("clojure", Optional.of(new WordLocation(new Pair(1, 1), new Pair(7, 1))));
+
+        Set<String> searchWords = expectedLocations.keySet();
+
+        Map<String, Optional<WordLocation>> actualLocations = wordSearcher.search(
+                searchWords,
+                new char[][]{
+                        {'c', 'l', 'o', 'j', 'u', 'r', 'e', 'r', 'm', 't'}
+                }
+        );
+
+        assertEquals(expectedLocations, actualLocations);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testShouldLocateTheSameWordLeftToRightInDifferentPosition() {
+        Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();
+        expectedLocations.put("clojure", Optional.of(new WordLocation(new Pair(3, 1), new Pair(9, 1))));
+
+        Set<String> searchWords = expectedLocations.keySet();
+
+        Map<String, Optional<WordLocation>> actualLocations = wordSearcher.search(
+                searchWords,
+                new char[][]{
+                        {'m', 't', 'c', 'l', 'o', 'j', 'u', 'r', 'e', 'r'}
+                }
+        );
+
+        assertEquals(expectedLocations, actualLocations);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testShouldLocateADifferentLeftToRightWord() {
+        Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();
+        expectedLocations.put("coffee", Optional.of(new WordLocation(new Pair(1, 1), new Pair(6, 1))));
+
+        Set<String> searchWords = expectedLocations.keySet();
+
+        Map<String, Optional<WordLocation>> actualLocations = wordSearcher.search(
+                searchWords,
+                new char[][]{
+                        {'c', 'o', 'f', 'f', 'e', 'e', 'l', 'p', 'l', 'x'}
+                }
+        );
+
+        assertEquals(expectedLocations, actualLocations);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testShouldLocateThatDifferentLeftToRightWordInADifferentPosition() {
+        Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();
+        expectedLocations.put("coffee", Optional.of(new WordLocation(new Pair(2, 1), new Pair(7, 1))));
+
+        Set<String> searchWords = expectedLocations.keySet();
+
+        Map<String, Optional<WordLocation>> actualLocations = wordSearcher.search(
+                searchWords,
+                new char[][]{
+                        {'x', 'c', 'o', 'f', 'f', 'e', 'e', 'z', 'l', 'p'}
+                }
+        );
+
+        assertEquals(expectedLocations, actualLocations);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testShouldLocateLeftToRightWordInTwoLineGrid() {
+        Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();
+        expectedLocations.put("clojure", Optional.of(new WordLocation(new Pair(2, 2), new Pair(8, 2))));
+
+        Set<String> searchWords = expectedLocations.keySet();
+
+        Map<String, Optional<WordLocation>> actualLocations = wordSearcher.search(
+                searchWords,
+                new char[][]{
+                        {'j', 'e', 'f', 'b', 'l', 'p', 'e', 'p', 'r', 'e'},
+                        {'t', 'c', 'l', 'o', 'j', 'u', 'r', 'e', 'r', 'm'}
+                }
+        );
+
+        assertEquals(expectedLocations, actualLocations);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testShouldLocateLeftToRightWordInThreeLineGrid() {
+        Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();
+        expectedLocations.put("clojure", Optional.of(new WordLocation(new Pair(1, 3), new Pair(7, 3))));
+
+        Set<String> searchWords = expectedLocations.keySet();
+
+        Map<String, Optional<WordLocation>> actualLocations = wordSearcher.search(
+                searchWords,
+                new char[][]{
+                        {'c', 'a', 'm', 'd', 'c', 'i', 'm', 'g', 't', 'c'},
+                        {'j', 'e', 'f', 'b', 'l', 'p', 'e', 'p', 'r', 'e'},
+                        {'c', 'l', 'o', 'j', 'u', 'r', 'e', 'r', 'm', 't'}
+                }
+        );
+
+        assertEquals(expectedLocations, actualLocations);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testLocatesWordWrittenLeftToRightInTenLineGrid() {
         Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();
         expectedLocations.put("clojure", Optional.of(new WordLocation(new Pair(1, 10), new Pair(7, 10))));
 
@@ -40,11 +170,112 @@ public class WordSearcherTest {
         assertEquals(expectedLocations, actualLocations);
     }
 
+    @Ignore("Remove to run test")
+    @Test
+    public void testLocatesSameWordWrittenLeftToRightInDifferentTenLineGrid() {
+        Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();
+        expectedLocations.put("clojure", Optional.of(new WordLocation(new Pair(1, 9), new Pair(7, 9))));
+
+        Set<String> searchWords = expectedLocations.keySet();
+
+        Map<String, Optional<WordLocation>> actualLocations = wordSearcher.search(
+                searchWords,
+                new char[][]{
+                        {'j', 'e', 'f', 'b', 'l', 'p', 'e', 'p', 'r', 'e'},
+                        {'c', 'a', 'm', 'd', 'c', 'i', 'm', 'g', 't', 'c'},
+                        {'o', 'i', 'v', 'o', 'k', 'p', 'r', 'j', 's', 'm'},
+                        {'p', 'b', 'w', 'a', 's', 'q', 'r', 'o', 'u', 'a'},
+                        {'r', 'i', 'x', 'i', 'l', 'e', 'l', 'h', 'r', 's'},
+                        {'w', 'o', 'l', 'c', 'q', 'l', 'i', 'r', 'p', 'c'},
+                        {'s', 'c', 'r', 'e', 'e', 'a', 'u', 'm', 'g', 'r'},
+                        {'a', 'l', 'x', 'h', 'p', 'b', 'u', 'r', 'y', 'i'},
+                        {'c', 'l', 'o', 'j', 'u', 'r', 'e', 'r', 'm', 't'},
+                        {'j', 'a', 'l', 'a', 'y', 'c', 'a', 'l', 'm', 'p'}
+                }
+        );
+
+        assertEquals(expectedLocations, actualLocations);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testLocatesDifferentWordWrittenLeftToRightInTenLineGrid() {
+        Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();
+        expectedLocations.put("fortran", Optional.of(new WordLocation(new Pair(1, 7), new Pair(7, 7))));
+
+        Set<String> searchWords = expectedLocations.keySet();
+
+        Map<String, Optional<WordLocation>> actualLocations = wordSearcher.search(
+                searchWords,
+                new char[][]{
+                        {'j', 'e', 'f', 'b', 'l', 'p', 'e', 'p', 'r', 'e'},
+                        {'c', 'a', 'm', 'd', 'c', 'i', 'm', 'g', 't', 'c'},
+                        {'o', 'i', 'v', 'o', 'k', 'p', 'r', 'j', 's', 'm'},
+                        {'p', 'b', 'w', 'a', 's', 'q', 'r', 'o', 'u', 'a'},
+                        {'r', 'i', 'x', 'i', 'l', 'e', 'l', 'h', 'r', 's'},
+                        {'w', 'o', 'l', 'c', 'q', 'l', 'i', 'r', 'p', 'c'},
+                        {'f', 'o', 'r', 't', 'r', 'a', 'n', 'f', 't', 'w'},
+                        {'a', 'l', 'x', 'h', 'p', 'b', 'u', 'r', 'y', 'i'},
+                        {'c', 'l', 'o', 'j', 'u', 'r', 'e', 'r', 'm', 't'},
+                        {'j', 'a', 'l', 'a', 'y', 'c', 'a', 'l', 'm', 'p'}
+                }
+        );
+
+        assertEquals(expectedLocations, actualLocations);
+    }
+
+    @Ignore("Remove to run test")
     @Test
-    public void testLocatesWordsWrittenRightToLeft() {
+    public void testShouldLocateMultipleWords() {
         Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();
+        expectedLocations.put("fortran",  Optional.of(new WordLocation(new Pair(1,  7), new Pair(7,  7))));
         expectedLocations.put("clojure", Optional.of(new WordLocation(new Pair(1, 10), new Pair(7, 10))));
+
+        Set<String> searchWords = expectedLocations.keySet();
+
+        Map<String, Optional<WordLocation>> actualLocations = wordSearcher.search(
+                searchWords,
+                new char[][]{
+                        {'j', 'e', 'f', 'b', 'l', 'p', 'e', 'p', 'r', 'e'},
+                        {'c', 'a', 'm', 'd', 'c', 'i', 'm', 'g', 't', 'c'},
+                        {'o', 'i', 'v', 'o', 'k', 'p', 'r', 'j', 's', 'm'},
+                        {'p', 'b', 'w', 'a', 's', 'q', 'r', 'o', 'u', 'a'},
+                        {'r', 'i', 'x', 'i', 'l', 'e', 'l', 'h', 'r', 's'},
+                        {'w', 'o', 'l', 'c', 'q', 'l', 'i', 'r', 'p', 'c'},
+                        {'f', 'o', 'r', 't', 'r', 'a', 'n', 'f', 't', 'w'},
+                        {'a', 'l', 'x', 'h', 'p', 'b', 'u', 'r', 'y', 'i'},
+                        {'j', 'a', 'l', 'a', 'y', 'c', 'a', 'l', 'm', 'p'},
+                        {'c', 'l', 'o', 'j', 'u', 'r', 'e', 'r', 'm', 't'}
+                }
+        );
+
+        assertEquals(expectedLocations, actualLocations);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testShouldLocateASingleWordRightToLeft() {
+        Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();
+        expectedLocations.put("elixir", Optional.of(new WordLocation(new Pair(6, 1), new Pair(1, 1))));
+
+        Set<String> searchWords = expectedLocations.keySet();
+
+        Map<String, Optional<WordLocation>> actualLocations = wordSearcher.search(
+                searchWords,
+                new char[][]{
+                        {'r', 'i', 'x', 'i', 'l', 'e', 'l', 'h', 'r', 's'}
+                }
+        );
+
+        assertEquals(expectedLocations, actualLocations);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testShouldLocateMultipleWordsWrittenInDifferentHorizontalDirections() {
+        Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();
         expectedLocations.put("elixir",  Optional.of(new WordLocation(new Pair(6,  5), new Pair(1,  5))));
+        expectedLocations.put("clojure", Optional.of(new WordLocation(new Pair(1, 10), new Pair(7, 10))));
 
         Set<String> searchWords = expectedLocations.keySet();
 
@@ -67,6 +298,7 @@ public class WordSearcherTest {
         assertEquals(expectedLocations, actualLocations);
     }
 
+    @Ignore("Remove to run test")
     @Test
     public void testLocatesWordsWrittenTopToBottom() {
         Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();
@@ -95,6 +327,7 @@ public class WordSearcherTest {
         assertEquals(expectedLocations, actualLocations);
     }
 
+    @Ignore("Remove to run test")
     @Test
     public void testLocatesWordsWrittenBottomToTop() {
         Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();
@@ -122,6 +355,7 @@ public class WordSearcherTest {
         assertEquals(expectedLocations, actualLocations);
     }
 
+    @Ignore("Remove to run test")
     @Test
     public void testLocatesWordsWrittenTopLeftToBottomRight() {
         Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();
@@ -150,6 +384,7 @@ public class WordSearcherTest {
         assertEquals(expectedLocations, actualLocations);
     }
 
+    @Ignore("Remove to run test")
     @Test
     public void testLocatesWordsWrittenBottomRightToTopLeft() {
         Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();
@@ -179,6 +414,7 @@ public class WordSearcherTest {
         assertEquals(expectedLocations, actualLocations);
     }
 
+    @Ignore("Remove to run test")
     @Test
     public void testLocatesWordsWrittenBottomLeftToTopRight() {
         Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();
@@ -209,6 +445,7 @@ public class WordSearcherTest {
         assertEquals(expectedLocations, actualLocations);
     }
 
+    @Ignore("Remove to run test")
     @Test
     public void testLocatesWordsWrittenTopRightToBottomLeft() {
         Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();
@@ -240,6 +477,7 @@ public class WordSearcherTest {
         assertEquals(expectedLocations, actualLocations);
     }
 
+    @Ignore("Remove to run test")
     @Test
     public void testFailsToLocateAWordsThatIsNotInThePuzzle() {
         Map<String, Optional<WordLocation>> expectedLocations = new HashMap<>();