Merge remote-tracking branch 'refs/remotes/exercism/master'

exercises/binary-search-tree/src/test/java/BSTTest.java

         List<Integer> treeData = Collections.unmodifiableList(
                 Arrays.asList(4, 2, 6, 1, 3, 7, 5)
         );
-        treeData.forEach(value -> sut.insert(value));
+        treeData.forEach(sut::insert);
 
         List<Integer> actual = sut.getAsLevelOrderList();
         assertEquals(expected, actual);
         List<Integer> treeData = Collections.unmodifiableList(
                 Arrays.asList(4, 2, 1, 3, 6, 7, 5)
         );
-        treeData.forEach(value -> sut.insert(value));
+        treeData.forEach(sut::insert);
 
         List<Integer> actual = sut.getAsSortedList();
         assertEquals(expected, actual);

exercises/change/src/test/java/ChangeCalculatorTest.java

                 changeCalculator.computeMostEfficientChange(25));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testChangeThatMustBeGivenInMultipleCoins() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 5, 10, 25, 100));
                 changeCalculator.computeMostEfficientChange(15));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     // https://en.wikipedia.org/wiki/Change-making_problem#Greedy_method
     public void testLilliputianCurrencyForWhichGreedyAlgorithmFails() {
                 changeCalculator.computeMostEfficientChange(23));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     // https://en.wikipedia.org/wiki/Change-making_problem#Greedy_method
     public void testLowerElbonianCurrencyForWhichGreedyAlgorithmFails() {
                 changeCalculator.computeMostEfficientChange(63));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLargeAmountOfChange() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 2, 5, 10, 20, 50, 100));
                 changeCalculator.computeMostEfficientChange(999));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testZeroChange() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 5, 10, 21, 25));
                 changeCalculator.computeMostEfficientChange(0));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testChangeLessThanSmallestCoinInCurrencyCannotBeRepresented() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(5, 10));
         changeCalculator.computeMostEfficientChange(3);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testChangeLargerThanAllCoinsInCurrencyThatCannotBeRepresented() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(5, 10));
         changeCalculator.computeMostEfficientChange(94);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testNegativeChangeIsRejected() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 2, 5));

exercises/clock/src/test/java/ClockAddTest.java

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

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

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

exercises/clock/src/test/java/ClockEqualTest.java

 
 public class ClockEqualTest {
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void clocksWithSameTimeAreEqual() {
         assertTrue(new Clock(15, 37).equals(new Clock(15, 37)));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void clocksAMinuteApartAreNotEqual() {
         assertFalse(new Clock(15, 36).equals(new Clock(15, 37)));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void clocksAnHourApartAreNotEqual() {
         assertFalse(new Clock(14, 37).equals(new Clock(15, 37)));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void clocksWithHourOverflow() {
         assertTrue(new Clock(10, 37).equals(new Clock(34, 37)));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void clocksWithHourOverflowBySeveralDays() {
         assertTrue(new Clock(3, 11).equals(new Clock(99, 11)));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void clocksWithNegateHour() {
         assertTrue(new Clock(22, 40).equals(new Clock(-2, 40)));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void clocksWithNegativeHourThatWraps() {
         assertTrue(new Clock(17, 3).equals(new Clock(-31, 3)));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void clocksWithNegativeHourThatWrapsMultipleTimes() {
         assertTrue(new Clock(13, 49).equals(new Clock(-83, 49)));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void clocksWithMinuteOverflow() {
         assertTrue(new Clock(0, 1).equals(new Clock(0, 1441)));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void clocksWithMinuteOverflowBySeveralDays() {
         assertTrue(new Clock(2, 2).equals(new Clock(2, 4322)));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void clocksWithNegativeMinutes() {
         assertTrue(new Clock(2, 40).equals(new Clock(3, -20)));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void clocksWithNegativeMinutesThatWraps() {
         assertTrue(new Clock(4, 10).equals(new Clock(5, -1490)));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void clocksWithNegativeMinutesThatWrapsMultipleTimes() {
         assertTrue(new Clock(6, 15).equals(new Clock(6, -4305)));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void clocksWithNegativeHoursAndMinutes() {
         assertTrue(new Clock(7, 32).equals(new Clock(-12, -268)));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void clocksWithNegativeHoursAndMinutesThatWrap() {
         assertTrue(new Clock(18, 7).equals(new Clock(-54, -11513)));

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

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

exercises/diamond/src/test/java/DiamondPrinterTest.java

         assertThat(output, is(singletonList("A")));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTwoByTwoDiamond() {
         List<String> output = diamondPrinter.printToList('B');
                                      " A ")));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThreeByThreeDiamond() {
         List<String> output = diamondPrinter.printToList('C');
                                      "  A  ")));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFiveByFiveDiamond() {
         List<String> output = diamondPrinter.printToList('E');
                                      "    A    ")));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFullDiamond() {
         List<String> output = diamondPrinter.printToList('Z');

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

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

exercises/flatten-array/src/test/java/FlattenerTest.java

                 "two")));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testASingleLevelOfNestingWithNoNulls() {
         assertEquals(
               8)));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFiveLevelsOfNestingWithNoNulls() {
         assertEquals(
               "-2")));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSixLevelsOfNestingWithNoNulls() {
         assertEquals(
               "8")));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSixLevelsOfNestingWithNulls() {
         assertEquals(
               "negative two")));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testNestedListsFullOfNullsOnly() {
         assertEquals(

exercises/grade-school/src/test/java/SchoolTest.java

     assertThat(school.numberOfStudents(), is(0));
   }
 
-  @Ignore
+  @Ignore("Remove to run test")
   @Test
   public void addsStudents() {
     school.add("Aimee", 2);
     assertThat(school.grade(2), hasItem("Aimee"));
   }
 
-  @Ignore
+  @Ignore("Remove to run test")
   @Test
   public void addsMoreStudentsInSameGrade() {
     final int grade = 2;
     assertThat(school.grade(grade), allOf(hasItem("James"), hasItem("Blair"), hasItem("Paul")));
   }
 
-  @Ignore
+  @Ignore("Remove to run test")
   @Test
   public void addsStudentsInMultipleGrades() {
     school.add("Chelsea", 3);
     assertThat(school.grade(7), hasItem("Logan"));
   }
 
-  @Ignore
+  @Ignore("Remove to run test")
   @Test
   public void getsStudentsInEmptyGrade() {
     assertTrue(school.grade(1).isEmpty());
   }
 
-  @Ignore
+  @Ignore("Remove to run test")
   @Test
   public void sortsSchool() {
     school.add("Kyle", 4);
     }
   }
 
-  @Ignore
+  @Ignore("Remove to run test")
   @Test
   public void modifyingFetchedGradeShouldNotModifyInternalDatabase() {
     String shouldNotBeAdded = "Should not be added to school";
     assertThat(school.grade(grade), not(hasItem(shouldNotBeAdded)));
   }
 
-  @Ignore
+  @Ignore("Remove to run test")
   @Test
   public void modifyingSortedStudentsShouldNotModifyInternalDatabase() {
     int grade = 2;

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

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

exercises/isogram/src/test/java/IsogramCheckerTest.java

         assertTrue(iso.isIsogram("duplicates"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testNotIsogram() {
         IsogramChecker iso = new IsogramChecker();
         assertFalse(iso.isIsogram("eleven"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testMediumLongIsogram() {
         IsogramChecker iso = new IsogramChecker();
         assertTrue(iso.isIsogram("subdermatoglyphic"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCaseInsensitive() {
         IsogramChecker iso = new IsogramChecker();
         assertFalse(iso.isIsogram("Alphabet"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testIsogramWithHyphen() {
         IsogramChecker iso = new IsogramChecker();
         assertTrue(iso.isIsogram("thumbscrew-japingly"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testIgnoresMultipleHyphens() {
         IsogramChecker iso = new IsogramChecker();
         assertTrue(iso.isIsogram("Hjelmqvist-Gryb-Zock-Pfund-Wax"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testWorksWithGermanLetters() {
         IsogramChecker iso = new IsogramChecker();
         assertTrue(iso.isIsogram("Heizölrückstoßabdämpfung"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testIgnoresSpaces() {
         IsogramChecker iso = new IsogramChecker();
         assertFalse(iso.isIsogram("the quick brown fox"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testIgnoresSpaces2() {
         IsogramChecker iso = new IsogramChecker();
         assertTrue(iso.isIsogram("Emily Jung Schwartzkopf"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testDuplicateAccentedLetters() {
         IsogramChecker iso = new IsogramChecker();

exercises/largest-series-product/src/test/java/LargestSeriesProductCalculatorTest.java

         assertEquals(expectedProduct, actualProduct);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLengthTwoWithNumbersNotInOrder() {
         final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("576802143");
         assertEquals(expectedProduct, actualProduct);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductWhenSeriesLengthEqualsStringToSearchLength() {
         final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("29");
         assertEquals(expectedProduct, actualProduct);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLengthThreeWithNumbersInOrder() {
         final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
         assertEquals(expectedProduct, actualProduct);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLengthThreeWithNumbersNotInOrder() {
         final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("1027839564");
         assertEquals(expectedProduct, actualProduct);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLengthFiveWithNumbersInOrder() {
         final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
         assertEquals(expectedProduct, actualProduct);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductInLongStringToSearchV1() {
         final LargestSeriesProductCalculator calculator
         assertEquals(expectedProduct, actualProduct);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductInLongStringToSearchV2() {
         final LargestSeriesProductCalculator calculator
         assertEquals(expectedProduct, actualProduct);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductInLongStringToSearchFromProjectEuler() {
         final LargestSeriesProductCalculator calculator
         assertEquals(expectedProduct, actualProduct);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfZeroIfAllDigitsAreZeroes() {
         final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0000");
         assertEquals(expectedProduct, actualProduct);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfZeroIfAllSeriesOfGivenLengthContainZero() {
         final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("99099");
         assertEquals(expectedProduct, actualProduct);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSeriesLengthLongerThanLengthOfStringToTestIsRejected() {
         final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("123");
         calculator.calculateLargestProductForSeriesLength(4);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLength0ForEmptyStringToSearch() {
         final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("");
         assertEquals(expectedProduct, actualProduct);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLength0ForNonEmptyStringToSearch() {
         final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("123");
         assertEquals(expectedProduct, actualProduct);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testEmptyStringToSearchAndSeriesOfNonZeroLengthIsRejected() {
         final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("");
         calculator.calculateLargestProductForSeriesLength(1);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testStringToSearchContainingNonDigitCharacterIsRejected() {
         expectedException.expect(IllegalArgumentException.class);
         new LargestSeriesProductCalculator("1234a5");
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testNegativeSeriesLengthIsRejected() {
         final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("12345");
         calculator.calculateLargestProductForSeriesLength(-1);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testNullStringToSearchIsRejected() {
         expectedException.expect(IllegalArgumentException.class);

exercises/linked-list/src/test/java/DoublyLinkedListTest.java

         assertThat(subject.pop(), is(10));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testPushShift() {
         subject.push(10);
         assertThat(subject.shift(), is(20));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testUnshiftShift() {
         subject.unshift(10);
         assertThat(subject.shift(), is(10));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testUnshiftPop() {
         subject.unshift(10);
         assertThat(subject.pop(), is(20));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testExample() {
         subject.push(10);

exercises/list-ops/src/test/java/ListOpsTest.java

     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldReturnTheCorrectLengthOfAnNonEmptyList() {
         final List<Integer> list = Collections.unmodifiableList(
                 Arrays.asList(0, 1, 2, 3, 4)
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldReverseAnEmptyList() {
         final List<Integer> actual = ListOps.reverse(EMPTY_LIST);
 
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldReverseANonEmptyList() {
         final List<Integer> list = Collections.unmodifiableList(
                 Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8)
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldMapAnEmptyListAndReturnAnEmptyList() {
         final List<Integer> actual = ListOps.map(EMPTY_LIST, x -> x + 1);
 
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldMapNonEmptyList() {
         final List<Integer> list
                 = Collections.unmodifiableList(Arrays.asList(1, 3, 5, 7));
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldFilterAnEmptyListanddReturnAnEmptyList() {
         final List<Integer> actual = ListOps.filter(EMPTY_LIST, x -> x > 0);
 
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldFilterNonEmptyList() {
         Predicate<Integer> predicate = x -> x % 2 > 0;
         final List<Integer> list = Collections.unmodifiableList(
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldConcatenateZeroLists() {
         List<Integer> actual = ListOps.concat();
 
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldConcatenateOneNonEmptyList() {
         final List<Integer> list
                 = Collections.unmodifiableList(
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldConcatenateOneEmptyList() {
         final List<Integer> actual = ListOps.concat(EMPTY_LIST);
 
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldConcatenateTwoEmptyLists() {
         final List<Integer> actual = ListOps.concat(EMPTY_LIST, EMPTY_LIST);
 
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldConcatenateOneEmptyAndOneNonEmptyLists() {
         final List<Integer> list
                 = Collections.unmodifiableList(
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldConcatenateOneNonEmptyAndOneEmptyLists() {
         final List<Integer> list
                 = Collections.unmodifiableList(
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldConcatenateTwoListsWithSameElements() {
         final List<Integer> list1 = Collections.unmodifiableList(
                 Arrays.asList(0, 1, 2, 3, 4)
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldConcatenateSeveralLists() {
         final List<Integer> list1 = Collections.unmodifiableList(
                 Arrays.asList(0, 1, 2, 3)
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldReturnIdentityWhenAnEmptyListIsReduced() {
         final int expected = 0;
         final int actual
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldCalculateTheSumOfANonEmptyIntegerList() {
         final List<Integer> list = Collections.unmodifiableList(
                 Arrays.asList(0, 1, 2, 3, 4)
             };
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldReduceAnEmptyListAndANonEmptyListAndReturnConcatenation() {
         final List<Integer> list = Collections.unmodifiableList(
                 Arrays.asList(0, 1, 2, 3, 4, 5)
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldReduceTwoNonEmptyListsAndReturnConcatenation() {
         final List<Integer> listOne = Collections.unmodifiableList(
                 Arrays.asList(0, 1, 2, 3, 4)

exercises/luhn/src/test/java/LuhnValidatorTest.java

         assertFalse(luhnValidator.isValid("1"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatTheStringConsistingOfASingleZeroIsInvalid() {
         assertFalse(luhnValidator.isValid("0"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatASimpleValidNumberIsIdentifiedAsValid() {
         assertTrue(luhnValidator.isValid(" 5 9 "));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatAValidCanadianSocialInsuranceNumberIsIdentifiedAsValidV1() {
         assertTrue(luhnValidator.isValid("046 454 286"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatAValidCanadianSocialInsuranceNumberIsIdentifiedAsValidV2() {
         assertTrue(luhnValidator.isValid("055 444 285"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatAnInvalidCanadianSocialInsuranceNumberIsIdentifiedAsInvalid() {
         assertFalse(luhnValidator.isValid("046 454 287"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatAnInvalidCreditCardIsIdentifiedAsInvalid() {
         assertFalse(luhnValidator.isValid("8273 1232 7352 0569"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatAddingANonDigitCharacterToAValidStringInvalidatesTheString() {
         assertFalse(luhnValidator.isValid("046a 454 286"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatStringContainingPunctuationIsInvalid() {
         assertFalse(luhnValidator.isValid("055-444-285"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatStringContainingSymbolsIsInvalid() {
         assertFalse(luhnValidator.isValid("055£ 444$ 285"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatTheStringConsistingOfASpaceAndASingleZeroIsInvalid() {
         assertFalse(luhnValidator.isValid(" 0"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatStringContainingMultipleZerosIsValid() {
         assertTrue(luhnValidator.isValid(" 00000"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatDoublingNineIsHandledCorrectly() {
         assertTrue(luhnValidator.isValid("091"));

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

         }
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @RunWith(Parameterized.class)
     public static class CountColumnsTest {
         private Matrix matrix;
         }
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @RunWith(Parameterized.class)
     public static class GetFirstRowTest {
         private Matrix matrix;
         }
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @RunWith(Parameterized.class)
     public static class GetLastRowTest {
         private Matrix matrix;
         }
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @RunWith(Parameterized.class)
     public static class GetFirstColumnTest {
         private Matrix matrix;
     }
 
 
-    @Ignore
+    @Ignore("Remove to run test")
     @RunWith(Parameterized.class)
     public static class GetLastColumnTest {
         private Matrix matrix;

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

         assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testMonteenthOfAugust2013() {
         LocalDate expected = LocalDate.of(2013, 8, 19);
         assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testMonteenthOfSeptember2013() {
         LocalDate expected = LocalDate.of(2013, 9, 16);
         assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTuesteenthOfMarch2013() {
         LocalDate expected = LocalDate.of(2013, 3, 19);
         assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTuesteenthOfApril2013() {
         LocalDate expected = LocalDate.of(2013, 4, 16);
         assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTuesteenthOfAugust2013() {
         LocalDate expected = LocalDate.of(2013, 8, 13);
         assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testWednesteenthOfJanuary2013() {
         LocalDate expected = LocalDate.of(2013, 1, 16);
         assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testWednesteenthOfFebruary2013() {
         LocalDate expected = LocalDate.of(2013, 2, 13);
         assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testWednesteenthOfJune2013() {
         LocalDate expected = LocalDate.of(2013, 6, 19);
         assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThursteenthOfMay2013() {
         LocalDate expected = LocalDate.of(2013, 5, 16);
         assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThursteenthOfJune2013() {
         LocalDate expected = LocalDate.of(2013, 6, 13);
         assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThursteenthOfSeptember2013() {
         LocalDate expected = LocalDate.of(2013, 9, 19);
         assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFriteenthOfApril2013() {
         LocalDate expected = LocalDate.of(2013, 4, 19);
         assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFriteenthOfAugust2013() {
         LocalDate expected = LocalDate.of(2013, 8, 16);
         assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFriteenthOfSeptember2013() {
         LocalDate expected = LocalDate.of(2013, 9, 13);
         assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSaturteenthOfFebruary2013() {
         LocalDate expected = LocalDate.of(2013, 2, 16);
         assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSaturteenthOfApril2013() {
         LocalDate expected = LocalDate.of(2013, 4, 13);
         assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSaturteenthOfOctober2013() {
         LocalDate expected = LocalDate.of(2013, 10, 19);
         assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSunteenthOfMay2013() {
         LocalDate expected = LocalDate.of(2013, 5, 19);
         assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSunteenthOfJune2013() {
         LocalDate expected = LocalDate.of(2013, 6, 16);
         assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSunteenthOfOctober2013() {
         LocalDate expected = LocalDate.of(2013, 10, 13);
         assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.TEENTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFirstMondayOfMarch2013() {
         LocalDate expected = LocalDate.of(2013, 3, 4);
         assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.FIRST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFirstMondayOfApril2013() {
         LocalDate expected = LocalDate.of(2013, 4, 1);
         assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.FIRST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFirstTuesdayOfMay2013() {
         LocalDate expected = LocalDate.of(2013, 5, 7);
         assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.FIRST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFirstTuesdayOfJune2013() {
         LocalDate expected = LocalDate.of(2013, 6, 4);
         assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.FIRST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFirstWednesdayOfJuly2013() {
         LocalDate expected = LocalDate.of(2013, 7, 3);
         assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.FIRST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFirstWednesdayOfAugust2013() {
         LocalDate expected = LocalDate.of(2013, 8, 7);
         assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.FIRST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFirstThursdayOfSeptember2013() {
         LocalDate expected = LocalDate.of(2013, 9, 5);
         assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.FIRST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFirstThursdayOfOctober2013() {
         LocalDate expected = LocalDate.of(2013, 10, 3);
         assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.FIRST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFirstFridayOfNovember2013() {
         LocalDate expected = LocalDate.of(2013, 11, 1);
         assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.FIRST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFirstFridayOfDecember2013() {
         LocalDate expected = LocalDate.of(2013, 12, 6);
         assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.FIRST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFirstSaturdayOfJanuary2013() {
         LocalDate expected = LocalDate.of(2013, 1, 5);
         assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.FIRST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFirstSaturdayOfFebruary2013() {
         LocalDate expected = LocalDate.of(2013, 2, 2);
         assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.FIRST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFirstSundayOfMarch2013() {
         LocalDate expected = LocalDate.of(2013, 3, 3);
         assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.FIRST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFirstSundayOfApril2013() {
         LocalDate expected = LocalDate.of(2013, 4, 7);
         assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.FIRST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSecondMondayOfMarch2013() {
         LocalDate expected = LocalDate.of(2013, 3, 11);
         assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.SECOND));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSecondMondayOfApril2013() {
         LocalDate expected = LocalDate.of(2013, 4, 8);
         assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.SECOND));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSecondTuesdayOfMay2013() {
         LocalDate expected = LocalDate.of(2013, 5, 14);
         assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.SECOND));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSecondTuesdayOfJune2013() {
         LocalDate expected = LocalDate.of(2013, 6, 11);
         assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.SECOND));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSecondWednesdayOfJuly2013() {
         LocalDate expected = LocalDate.of(2013, 7, 10);
         assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.SECOND));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSecondWednesdayOfAugust2013() {
         LocalDate expected = LocalDate.of(2013, 8, 14);
         assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.SECOND));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSecondThursdayOfSeptember2013() {
         LocalDate expected = LocalDate.of(2013, 9, 12);
         assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.SECOND));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSecondThursdayOfOctober2013() {
         LocalDate expected = LocalDate.of(2013, 10, 10);
         assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.SECOND));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSecondFridayOfNovember2013() {
         LocalDate expected = LocalDate.of(2013, 11, 8);
         assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.SECOND));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSecondFridayOfDecember2013() {
         LocalDate expected = LocalDate.of(2013, 12, 13);
         assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.SECOND));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSecondSaturdayOfJanuary2013() {
         LocalDate expected = LocalDate.of(2013, 1, 12);
         assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.SECOND));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSecondSaturdayOfFebruary2013() {
         LocalDate expected = LocalDate.of(2013, 2, 9);
         assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.SECOND));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSecondSundayOfMarch2013() {
         LocalDate expected = LocalDate.of(2013, 3, 10);
         assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.SECOND));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSecondSundayOfApril2013() {
         LocalDate expected = LocalDate.of(2013, 4, 14);
         assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.SECOND));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThirdMondayOfMarch2013() {
         LocalDate expected = LocalDate.of(2013, 3, 18);
         assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.THIRD));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThirdMondayOfApril2013() {
         LocalDate expected = LocalDate.of(2013, 4, 15);
         assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.THIRD));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThirdTuesdayOfMay2013() {
         LocalDate expected = LocalDate.of(2013, 5, 21);
         assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.THIRD));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThirdTuesdayOfJune2013() {
         LocalDate expected = LocalDate.of(2013, 6, 18);
         assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.THIRD));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThirdWednesdayOfJuly2013() {
         LocalDate expected = LocalDate.of(2013, 7, 17);
         assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.THIRD));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThirdWednesdayOfAugust2013() {
         LocalDate expected = LocalDate.of(2013, 8, 21);
         assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.THIRD));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThirdThursdayOfSeptember2013() {
         LocalDate expected = LocalDate.of(2013, 9, 19);
         assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.THIRD));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThirdThursdayOfOctober2013() {
         LocalDate expected = LocalDate.of(2013, 10, 17);
         assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.THIRD));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThirdFridayOfNovember2013() {
         LocalDate expected = LocalDate.of(2013, 11, 15);
         assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.THIRD));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThirdFridayOfDecember2013() {
         LocalDate expected = LocalDate.of(2013, 12, 20);
         assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.THIRD));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThirdSaturdayOfJanuary2013() {
         LocalDate expected = LocalDate.of(2013, 1, 19);
         assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.THIRD));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThirdSaturdayOfFebruary2013() {
         LocalDate expected = LocalDate.of(2013, 2, 16);
         assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.THIRD));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThirdSundayOfMarch2013() {
         LocalDate expected = LocalDate.of(2013, 3, 17);
         assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.THIRD));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThirdSundayOfApril2013() {
         LocalDate expected = LocalDate.of(2013, 4, 21);
         assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.THIRD));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFourthMondayOfMarch2013() {
         LocalDate expected = LocalDate.of(2013, 3, 25);
         assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.FOURTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFourthMondayOfApril2013() {
         LocalDate expected = LocalDate.of(2013, 4, 22);
         assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.FOURTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFourthTuesdayOfMay2013() {
         LocalDate expected = LocalDate.of(2013, 5, 28);
         assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.FOURTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFourthTuesdayOfJune2013() {
         LocalDate expected = LocalDate.of(2013, 6, 25);
         assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.FOURTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFourthWednesdayOfJuly2013() {
         LocalDate expected = LocalDate.of(2013, 7, 24);
         assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.FOURTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFourthWednesdayOfAugust2013() {
         LocalDate expected = LocalDate.of(2013, 8, 28);
         assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.FOURTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFourthThursdayOfSeptember2013() {
         LocalDate expected = LocalDate.of(2013, 9, 26);
         assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.FOURTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFourthThursdayOfOctober2013() {
         LocalDate expected = LocalDate.of(2013, 10, 24);
         assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.FOURTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFourthFridayOfNovember2013() {
         LocalDate expected = LocalDate.of(2013, 11, 22);
         assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.FOURTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFourthFridayOfDecember2013() {
         LocalDate expected = LocalDate.of(2013, 12, 27);
         assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.FOURTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFourthSaturdayOfJanuary2013() {
         LocalDate expected = LocalDate.of(2013, 1, 26);
         assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.FOURTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFourthSaturdayOfFebruary2013() {
         LocalDate expected = LocalDate.of(2013, 2, 23);
         assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.FOURTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFourthSundayOfMarch2013() {
         LocalDate expected = LocalDate.of(2013, 3, 24);
         assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.FOURTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFourthSundayOfApril2013() {
         LocalDate expected = LocalDate.of(2013, 4, 28);
         assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.FOURTH));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLastMondayOfMarch2013() {
         LocalDate expected = LocalDate.of(2013, 3, 25);
         assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.LAST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLastMondayOfApril2013() {
         LocalDate expected = LocalDate.of(2013, 4, 29);
         assertEquals(expected, meetup.day(DayOfWeek.MONDAY, MeetupSchedule.LAST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLastTuesdayOfMay2013() {
         LocalDate expected = LocalDate.of(2013, 5, 28);
         assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.LAST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLastTuesdayOfJune2013() {
         LocalDate expected = LocalDate.of(2013, 6, 25);
         assertEquals(expected, meetup.day(DayOfWeek.TUESDAY, MeetupSchedule.LAST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLastWednesdayOfJuly2013() {
         LocalDate expected = LocalDate.of(2013, 7, 31);
         assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.LAST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLastWednesdayOfAugust2013() {
         LocalDate expected = LocalDate.of(2013, 8, 28);
         assertEquals(expected, meetup.day(DayOfWeek.WEDNESDAY, MeetupSchedule.LAST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLastThursdayOfSeptember2013() {
         LocalDate expected = LocalDate.of(2013, 9, 26);
         assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.LAST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLastThursdayOfOctober2013() {
         LocalDate expected = LocalDate.of(2013, 10, 31);
         assertEquals(expected, meetup.day(DayOfWeek.THURSDAY, MeetupSchedule.LAST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLastFridayOfNovember2013() {
         LocalDate expected = LocalDate.of(2013, 11, 29);
         assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.LAST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLastFridayOfDecember2013() {
         LocalDate expected = LocalDate.of(2013, 12, 27);
         assertEquals(expected, meetup.day(DayOfWeek.FRIDAY, MeetupSchedule.LAST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLastSaturdayOfJanuary2013() {
         LocalDate expected = LocalDate.of(2013, 1, 26);
         assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.LAST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLastSaturdayOfFebruary2013() {
         LocalDate expected = LocalDate.of(2013, 2, 23);
         assertEquals(expected, meetup.day(DayOfWeek.SATURDAY, MeetupSchedule.LAST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLastSundayOfMarch2013() {
         LocalDate expected = LocalDate.of(2013, 3, 31);
         assertEquals(expected, meetup.day(DayOfWeek.SUNDAY, MeetupSchedule.LAST));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLastSundayOfApril2013() {
         LocalDate expected = LocalDate.of(2013, 4, 28);

exercises/minesweeper/src/test/java/MinesweeperBoardTest.java

         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithOneRowAndNoColumns() {
         final List<String> inputBoard = Collections.singletonList("");
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithNoMines() {
         final List<String> inputBoard = Arrays.asList(
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithOnlyMines() {
         final List<String> inputBoard = Arrays.asList(
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithSingleMineAtCenter() {
         final List<String> inputBoard = Arrays.asList(
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithMinesAroundPerimeter() {
         final List<String> inputBoard = Arrays.asList(
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithSingleRowAndTwoMines() {
         final List<String> inputBoard = Collections.singletonList(
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithSingleRowAndTwoMinesAtEdges() {
         final List<String> inputBoard = Collections.singletonList(
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithSingleColumnAndTwoMines() {
         final List<String> inputBoard = Arrays.asList(
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithSingleColumnAndTwoMinesAtEdges() {
         final List<String> inputBoard = Arrays.asList(
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithMinesInCross() {
         final List<String> inputBoard = Arrays.asList(
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLargeInputBoard() {
         final List<String> inputBoard = Arrays.asList(
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testNullInputBoardIsRejected() {
         expectedException.expect(IllegalArgumentException.class);
         new MinesweeperBoard(null);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithInvalidSymbolsIsRejected() {
         expectedException.expect(IllegalArgumentException.class);
         new MinesweeperBoard(Collections.singletonList(" * & "));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithInconsistentRowLengthsIsRejected() {
         expectedException.expect(IllegalArgumentException.class);

exercises/nth-prime/src/test/java/PrimeCalculatorTest.java

         assertThat(primeCalculator.nth(1), is(2));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSecondPrime() {
         assertThat(primeCalculator.nth(2), is(3));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSixthPrime() {
         assertThat(primeCalculator.nth(6), is(13));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testBigPrime() {
         assertThat(primeCalculator.nth(10001), is(104743));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testUndefinedPrime() {
         thrown.expect(IllegalArgumentException.class);

exercises/nucleotide-count/src/test/java/NucleotideTest.java

         assertThat(dna.count('A'), is(0));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testEmptyDnaStringHasNoNucleotides() {
         DNA dna = new DNA("");
         ));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testRepetitiveCytosineGetsCounted() {
         DNA dna = new DNA("CCCCC");
         assertThat(dna.count('C'), is(5));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testRepetitiveSequenceWithOnlyGuanine() {
         DNA dna = new DNA("GGGGGGGG");
         ));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCountsOnlyThymine() {
         DNA dna = new DNA("GGGGGTAACCCGG");
         assertThat(dna.count('T'), is(1));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCountsANucleotideOnlyOnce() {
         DNA dna = new DNA("CGATTGGG");
         assertThat(dna.count('T'), is(2));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testDnaCountsDoNotChangeAfterCountingAdenine() {
         DNA dna = new DNA("GATTACA");
         ));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testValidatesNucleotides() {
         thrown.expect(IllegalArgumentException.class);
         dna.count('X');
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCountsAllNucleotides() {
         String s = "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC";

exercises/palindrome-products/src/test/java/PalindromeCalculatorTest.java

     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void largestPalindromeFromDoubleDigitFactors() {
         final List<List<Integer>> expected = Collections.unmodifiableList(
                 Arrays.asList(
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void smallestPalindromeFromDoubleDigitFactors() {
         final List<List<Integer>> expected = Collections.unmodifiableList(
                 Arrays.asList(
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void largestPalindromeFromTripleDigitFactors() {
         final List<List<Integer>> expected = Collections.unmodifiableList(
                 Arrays.asList(
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void smallestPalindromeFromTripleDigitFactors() {
         final List<List<Integer>> expected = Collections.unmodifiableList(
                 Arrays.asList(

exercises/pascals-triangle/src/test/java/PascalsTriangleGeneratorTest.java

         assertArrayEquals(expectedOutput, pascalsTriangleGenerator.generateTriangle(0));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTriangleWithOneRow() {
         int[][] expectedOutput = new int[][]{
         assertArrayEquals(expectedOutput, pascalsTriangleGenerator.generateTriangle(1));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTriangleWithTwoRows() {
         int[][] expectedOutput = new int[][]{
         assertArrayEquals(expectedOutput, pascalsTriangleGenerator.generateTriangle(2));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTriangleWithThreeRows() {
         int[][] expectedOutput = new int[][]{
         assertArrayEquals(expectedOutput, pascalsTriangleGenerator.generateTriangle(3));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTriangleWithFourRows() {
         int[][] expectedOutput = new int[][]{
         assertArrayEquals(expectedOutput, pascalsTriangleGenerator.generateTriangle(4));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testValidatesNotNegativeRows() {
         thrown.expect(IllegalArgumentException.class);

exercises/phone-number/src/test/java/PhoneNumberTest.java

         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cleansNumberWithDots() {
         final String expectedNumber = "1234567890";
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cleansNumberWithMultipleSpaces() {
         final String expectedNumber = "1234567890";
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void invalidWhen9Digits() {
         expectedException.expect(IllegalArgumentException.class);
         new PhoneNumber("123456789");
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void invalidWhen11Digits() {
         expectedException.expect(IllegalArgumentException.class);
         new PhoneNumber("21234567890");
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void validWhen11DigitsAndFirstIs1() {
         final String expectedNumber = "1234567890";
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void invalidWhen12Digits() {
         expectedException.expect(IllegalArgumentException.class);
         new PhoneNumber("321234567890");
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void invalidWithLetters() {
         expectedException.expect(IllegalArgumentException.class);
         new PhoneNumber("123-abc-7890");
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void invalidWithPunctuation() {
         expectedException.expect(IllegalArgumentException.class);
         new PhoneNumber("123-@:!-7890");
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void invalidWithRightNumberOfDigitsButLettersMixedIn() {
         expectedException.expect(IllegalArgumentException.class);

exercises/pythagorean-triplet/src/test/java/PythagoreanTripletTest.java

     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldCalculateProduct() {
         PythagoreanTriplet sut = new PythagoreanTriplet(3, 4, 5);
         final long expected = 60l;
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void testIsPythagoreanOK() {
         PythagoreanTriplet sut = new PythagoreanTriplet(3, 4, 5);
         assertTrue(sut.isPythagorean());
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void testIsPythagoreanFail() {
         PythagoreanTriplet sut = new PythagoreanTriplet(5, 6, 7);
         assertFalse(sut.isPythagorean());
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldMakeTripletsUpToTen() {
         final List<Long> actual
                 = PythagoreanTriplet
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldMakeTripletsElevenToTwenty() {
         final List<Long> actual
                 = PythagoreanTriplet
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void shouldMakeTripletsAndFilterOnSum() {
         final List<Long> actual
                 = PythagoreanTriplet

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

         assertFalse(calculator.canQueensAttackOneAnother());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testQueensCanAttackOnTheSameRank() {
         final QueenAttackCalculator calculator
         assertTrue(calculator.canQueensAttackOneAnother());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testQueensCanAttackOnTheSameFile() {
         final QueenAttackCalculator calculator
         assertTrue(calculator.canQueensAttackOneAnother());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testQueensCanAttackOnFirstDiagonal() {
         final QueenAttackCalculator calculator
         assertTrue(calculator.canQueensAttackOneAnother());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testQueensCanAttackOnSecondDiagonal() {
         final QueenAttackCalculator calculator
         assertTrue(calculator.canQueensAttackOneAnother());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testQueensCanAttackOnThirdDiagonal() {
         final QueenAttackCalculator calculator
         assertTrue(calculator.canQueensAttackOneAnother());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testQueensCanAttackOnFourthDiagonal() {
         final QueenAttackCalculator calculator
         assertTrue(calculator.canQueensAttackOneAnother());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCoordinateWithNegativeRankNotAllowed() {
         expectedException.expect(IllegalArgumentException.class);
         new BoardCoordinate(-2, 2);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCoordinateWithRankGreaterThan7NotAllowed() {
         expectedException.expect(IllegalArgumentException.class);
         new BoardCoordinate(8, 4);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCoordinateWithNegativeFileNotAllowed() {
         expectedException.expect(IllegalArgumentException.class);
         new BoardCoordinate(2, -2);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testCoordinateWithFileGreaterThan7NotAllowed() {
         expectedException.expect(IllegalArgumentException.class);
         new BoardCoordinate(4, 8);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testNullCoordinateNotAllowed() {
         expectedException.expect(IllegalArgumentException.class);
         new QueenAttackCalculator(null, new BoardCoordinate(0, 7));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testQueensMustNotOccupyTheSameSquare() {
         expectedException.expect(IllegalArgumentException.class);

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

         assertEquals(0, rectangleCounter.countRectangles(inputGrid));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testNonTrivialInputWithNoRectangles() {
         String[] inputGrid = new String[]{" "};
         assertEquals(0, rectangleCounter.countRectangles(inputGrid));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInputWithOneRectangle() {
         String[] inputGrid = new String[]{
         assertEquals(1, rectangleCounter.countRectangles(inputGrid));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInputWithTwoRectanglesWithoutSharedEdges() {
         String[] inputGrid = new String[]{
         assertEquals(2, rectangleCounter.countRectangles(inputGrid));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInputWithFiveRectanglesWithSharedEdges() {
         String[] inputGrid = new String[]{
         assertEquals(5, rectangleCounter.countRectangles(inputGrid));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatRectangleOfHeightOneIsCounted() {
         String[] inputGrid = new String[]{
         assertEquals(1, rectangleCounter.countRectangles(inputGrid));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatRectangleOfWidthOneIsCounted() {
         String[] inputGrid = new String[]{
         assertEquals(1, rectangleCounter.countRectangles(inputGrid));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatOneByOneSquareIsCounted() {
         String[] inputGrid = new String[]{
         assertEquals(1, rectangleCounter.countRectangles(inputGrid));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatIncompleteRectanglesAreNotCounted() {
         String[] inputGrid = new String[]{
         assertEquals(1, rectangleCounter.countRectangles(inputGrid));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatRectanglesOfDifferentSizesAreAllCounted() {
         String[] inputGrid = new String[]{
         assertEquals(3, rectangleCounter.countRectangles(inputGrid));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatIntersectionsWithoutCornerCharacterDoNotCountAsRectangleCorners() {
         String[] inputGrid = new String[]{
         assertEquals(2, rectangleCounter.countRectangles(inputGrid));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testLargeInputWithManyRectangles() {
         String[] inputGrid = new String[]{

exercises/robot-name/src/test/java/RobotTest.java

         assertIsValidName(robot.getName());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void differentRobotsHaveDifferentNames() {
         assertThat(robot.getName(), not(equalTo(new Robot().getName())));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void resetName() {
         final String name = robot.getName();

exercises/robot-simulator/src/test/java/RobotTest.java

         assertTrue(robot.getGridPosition().equals(initialGridPosition));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testRobotIsCreatedWithCorrectInitialOrientation() {
         final Orientation initialOrientation = Orientation.NORTH;
         assertTrue(robot.getOrientation().equals(initialOrientation));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTurningRightDoesNotChangePosition() {
         final GridPosition initialGridPosition = new GridPosition(0, 0);
         assertTrue(robot.getGridPosition().equals(initialGridPosition));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTurningRightCorrectlyChangesOrientationFromNorthToEast() {
         final Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);
         assertTrue(robot.getOrientation().equals(expectedOrientation));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTurningRightCorrectlyChangesOrientationFromEastToSouth() {
         final Robot robot = new Robot(new GridPosition(0, 0), Orientation.EAST);
         assertTrue(robot.getOrientation().equals(expectedOrientation));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTurningRightCorrectlyChangesOrientationFromSouthToWest() {
         final Robot robot = new Robot(new GridPosition(0, 0), Orientation.SOUTH);
         assertTrue(robot.getOrientation().equals(expectedOrientation));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTurningRightCorrectlyChangesOrientationFromWestToNorth() {
         final Robot robot = new Robot(new GridPosition(0, 0), Orientation.WEST);
         assertTrue(robot.getOrientation().equals(expectedOrientation));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTurningLeftDoesNotChangePosition() {
         final GridPosition initialGridPosition = new GridPosition(0, 0);
         assertTrue(robot.getGridPosition().equals(initialGridPosition));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTurningLeftCorrectlyChangesOrientationFromNorthToWest() {
         final Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);
         assertTrue(robot.getOrientation().equals(expectedOrientation));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTurningLeftCorrectlyChangesOrientationFromWestToSouth() {
         final Robot robot = new Robot(new GridPosition(0, 0), Orientation.WEST);
         assertTrue(robot.getOrientation().equals(expectedOrientation));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTurningLeftCorrectlyChangesOrientationFromSouthToEast() {
         final Robot robot = new Robot(new GridPosition(0, 0), Orientation.SOUTH);
         assertTrue(robot.getOrientation().equals(expectedOrientation));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testTurningLeftCorrectlyChangesOrientationFromEastToNorth() {
         final Robot robot = new Robot(new GridPosition(0, 0), Orientation.EAST);
         assertTrue(robot.getOrientation().equals(expectedOrientation));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testAdvancingDoesNotChangeOrientation() {
         final Orientation initialOrientation = Orientation.NORTH;
         assertTrue(robot.getOrientation().equals(initialOrientation));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testAdvancingWhenFacingNorthIncreasesYCoordinateByOne() {
         final Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);
         assertTrue(robot.getGridPosition().equals(expectedGridPosition));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testAdvancingWhenFacingSouthDecreasesYCoordinateByOne() {
         final Robot robot = new Robot(new GridPosition(0, 0), Orientation.SOUTH);
         assertTrue(robot.getGridPosition().equals(expectedGridPosition));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testAdvancingWhenFacingEastIncreasesXCoordinateByOne() {
         final Robot robot = new Robot(new GridPosition(0, 0), Orientation.EAST);
         assertTrue(robot.getGridPosition().equals(expectedGridPosition));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testAdvancingWhenFacingWestDecreasesXCoordinateByOne() {
         final Robot robot = new Robot(new GridPosition(0, 0), Orientation.WEST);
         assertTrue(robot.getGridPosition().equals(expectedGridPosition));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInstructionsToMoveWestAndNorth() {
         final Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);
         assertTrue(robot.getOrientation().equals(expectedOrientation));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInstructionsToMoveWestAndSouth() {
         final Robot robot = new Robot(new GridPosition(2, -7), Orientation.EAST);
         assertTrue(robot.getOrientation().equals(expectedOrientation));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInstructionsToMoveEastAndNorth() {
         final Robot robot = new Robot(new GridPosition(8, 4), Orientation.SOUTH);

exercises/series/src/test/java/SeriesTest.java

     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void hasDigitsLong() {
         Series sut = new Series("0123456789");
         List<Integer> expected = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void keepsTheDigitOrderIfReversed() {
         Series sut = new Series("9876543210");
         List<Integer> expected = Arrays.asList(9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void keepsArbitraryDigitOrder() {
         Series sut = new Series("936923468");
         List<Integer> expected = Arrays.asList(9, 3, 6, 9, 2, 3, 4, 6, 8);
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void canSliceByOne() {
         Series sut = new Series("01234");
         List<List<Integer>> expected = Arrays.asList(
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void canSliceByTwo() {
         Series sut = new Series("98273463");
         List<List<Integer>> expected = Arrays.asList(
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void canSliceByThree() {
         Series sut = new Series("01234");
         List<List<Integer>> expected = Arrays.asList(
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void canSliceByThreeWithDuplicateDigits() {
         Series sut = new Series("31001");
         List<List<Integer>> expected = Arrays.asList(
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void canSliceByFour() {
         Series sut = new Series("91274");
         List<List<Integer>> expected = Arrays.asList(
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void canSliceByFive() {
         Series sut = new Series("81228");
         List<List<Integer>> expected = Arrays.asList(
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void throwsAnErrorIfNotEnoughDigitsToSlice() {
         thrown.expect(IllegalArgumentException.class);
         new Series("01032987583").slices(12);

exercises/sieve/src/test/java/SieveTest.java

         assertEquals(expectedOutput, sieve.getPrimes());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void findPrimesUpTo10() {
         Sieve sieve = new Sieve(10);
         assertEquals(expectedOutput, sieve.getPrimes());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void findPrimesUpTo1000() {
         Sieve sieve = new Sieve(1000);

exercises/simple-cipher/src/test/java/SimpleCipherStepOneTest.java

         assertEquals(cipherText, cipherWithDefaultKey.encode("aaaaaaaaaa"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cipherCanDecode() {
         String cipherText = "aaaaaaaaaa";
         assertEquals(cipherText, cipherWithDefaultKey.decode(cipherWithDefaultKey.getKey().substring(0, 10)));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cipherIsReversible() {
         String plainText = "abcdefghij";

exercises/simple-cipher/src/test/java/SimpleCipherStepThreeTest.java

     @Rule
     public ExpectedException expectedException = ExpectedException.none();
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cipherKeyIsMadeOfLetters() {
         assertTrue(new Cipher().getKey().matches("[a-z]+"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void defaultCipherKeyIs100Characters() {
         assertEquals(100, new Cipher().getKey().length());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cipherKeysAreRandomlyGenerated() {
         String newKey = new Cipher().getKey();
                 "both returned key: " + newKey, newKey.equals(new Cipher().getKey()));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cipherThrowsWithAllCapsKey() {
         expectedException.expect(IllegalArgumentException.class);
         new Cipher("ABCDEF");
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cipherThrowsWithAnyCapsKey() {
         expectedException.expect(IllegalArgumentException.class);
         new Cipher("abcdEFg");
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cipherThrowsWithNumericKey() {
         expectedException.expect(IllegalArgumentException.class);
         new Cipher("12345");
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cipherThrowsWithAnyNumericKey() {
         expectedException.expect(IllegalArgumentException.class);

exercises/simple-cipher/src/test/java/SimpleCipherStepTwoTest.java

         cipherWithSetKey = new Cipher(key);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cipherKeepsTheSubmittedKey() {
         assertEquals(key, cipherWithSetKey.getKey());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cipherThrowsWithEmptyKey() {
         expectedException.expect(IllegalArgumentException.class);
         new Cipher("");
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cipherCanEncodeWithGivenKey() {
         String cipherText = "abcdefghij";
         assertEquals(cipherText, cipherWithSetKey.encode("aaaaaaaaaa"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cipherCanDecodeWithGivenKey() {
         String cipherText = "aaaaaaaaaa";
         assertEquals(cipherText, cipherWithSetKey.decode("abcdefghij"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cipherIsReversibleGivenKey() {
         String plainText = "abcdefghij";
         assertEquals(plainText, cipherWithSetKey.decode(cipherWithSetKey.encode("abcdefghij")));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cipherCanWrapEncode() {
         String cipherText = "zabcdefghi";
         assertEquals(cipherText, cipherWithSetKey.encode("zzzzzzzzzz"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cipherCanEncodeMessageThatIsShorterThanTheKey() {
         String cipherText = "abcde";
         assertEquals(cipherText, cipherWithSetKey.encode("aaaaa"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cipherCanDecodeMessageThatIsShorterThanTheKey() {
         String cipherText = "aaaaa";
         assertEquals(cipherText, cipherWithSetKey.decode("abcde"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void cipherCanDoubleShiftEncode() {
         String plainText = "iamapandabear";

exercises/sublist/src/test/java/RelationshipComputerTest.java

         assertEquals(Relationship.EQUAL, computedRelationship);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testEmptyListIsSublistOfNonEmptyList() {
         Relationship relationship = new RelationshipComputer<>().computeRelationship(
         assertEquals(Relationship.SUBLIST, relationship);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testNonEmptyListIsSuperlistOfEmptyList() {
         Relationship relationship = new RelationshipComputer<>().computeRelationship(
         assertEquals(Relationship.SUPERLIST, relationship);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testListIsEqualToItself() {
         List<String> anyList = asList("1", "2", "3");
         assertEquals(Relationship.EQUAL, relationship);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testDifferentListsOfTheSameLengthAreUnequal() {
         Relationship relationship = new RelationshipComputer<>().computeRelationship(
         assertEquals(Relationship.UNEQUAL, relationship);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSublistCheckDoesNotAbortAfterFalseStart() {
         Relationship relationship = new RelationshipComputer<>().computeRelationship(
         assertEquals(Relationship.SUBLIST, relationship);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSublistCheckHandlesExtraneousRepeatsOfFirstEntry() {
         Relationship relationship = new RelationshipComputer<>().computeRelationship(
         assertEquals(Relationship.SUBLIST, relationship);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSublistAtStart() {
         Relationship relationship = new RelationshipComputer<>().computeRelationship(
         assertEquals(Relationship.SUBLIST, relationship);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSublistInMiddle() {
         Relationship relationship = new RelationshipComputer<>().computeRelationship(
         assertEquals(Relationship.SUBLIST, relationship);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSublistAtEnd() {
         Relationship relationship = new RelationshipComputer<>().computeRelationship(
         assertEquals(Relationship.SUBLIST, relationship);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testAtStartOfSuperlist() {
         Relationship relationship = new RelationshipComputer<>().computeRelationship(
         assertEquals(Relationship.SUPERLIST, relationship);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInMiddleOfSuperlist() {
         Relationship relationship = new RelationshipComputer<>().computeRelationship(
         assertEquals(Relationship.SUPERLIST, relationship);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testAtEndOfSuperlist() {
         Relationship relationship = new RelationshipComputer<>().computeRelationship(
         assertEquals(Relationship.SUPERLIST, relationship);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testFirstListMissingElementFromSecondList() {
         Relationship relationship = new RelationshipComputer<>().computeRelationship(
         assertEquals(Relationship.UNEQUAL, relationship);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSecondListMissingElementFromFirstList() {
         Relationship relationship = new RelationshipComputer<>().computeRelationship(
         assertEquals(Relationship.UNEQUAL, relationship);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatListOrderingIsAccountedFor() {
         Relationship relationship = new RelationshipComputer<>().computeRelationship(
         assertEquals(Relationship.UNEQUAL, relationship);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testThatListsWithSameDigitsButDifferentNumbersAreUnequal() {
         Relationship relationship = new RelationshipComputer<>().computeRelationship(

exercises/sum-of-multiples/src/test/java/SumOfMultiplesTest.java

     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void testSumOfMultiplesOf3and5UpToFour() {
 
         int[] set = {
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void testSumOfMultiplesOf3and5UpToTen() {
 
         int[] set = {
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void testSumOfMultiplesOf3and5UpToOneHundred() {
 
         int[] set = {
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void testSumOfMultiplesOf3and5UpToOneThousand() {
 
         int[] set = {
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void testSumOfMultiplesOf7and13and17UpToTwenty() {
 
         int[] set = {
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void testSumOfMultiplesOf4and6UpToFifteen() {
 
         int[] set = {
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void testSumOfMultiplesOf5and6and8UpToOneHundredFifty() {
 
         int[] set = {
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void testSumOfMultiplesOf5and25UpToTwoHundredSeventyFive() {
 
         int[] set = {
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void testSumOfMultiplesOf43and47UpToTenThousand() {
 
         int[] set = {
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void testSumOfMultiplesOfOneUpToOneHundred() {
 
         int[] set = {
     }
 
     @Test
-    @Ignore
+    @Ignore("Remove to run test")
     public void testSumOfMultiplesOfNoneUpToTenThousand() {
 
         int[] set = {};

exercises/triangle/src/test/java/TriangleTest.java

         assertEquals(TriangleKind.EQUILATERAL, triangle.getKind());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void largerEquilateralTrianglesAlsoHaveEqualSides() throws TriangleException {
         Triangle triangle = new Triangle(10, 10, 10);
         assertEquals(TriangleKind.EQUILATERAL, triangle.getKind());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void isoscelesTrianglesHaveLastTwoSidesEqual() throws TriangleException {
         Triangle triangle = new Triangle(3, 4, 4);
         assertEquals(TriangleKind.ISOSCELES, triangle.getKind());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void isoscelesTrianglesHaveFirstAndLastSidesEqual() throws TriangleException {
         Triangle triangle = new Triangle(4, 3, 4);
         assertEquals(TriangleKind.ISOSCELES, triangle.getKind());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void isoscelesTrianglesHaveTwoFirstSidesEqual() throws TriangleException {
         Triangle triangle = new Triangle(4, 4, 3);
         assertEquals(TriangleKind.ISOSCELES, triangle.getKind());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void isoscelesTrianglesHaveInFactExactlyTwoSidesEqual() throws TriangleException {
         Triangle triangle = new Triangle(10, 10, 2);
         assertEquals(TriangleKind.ISOSCELES, triangle.getKind());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void scaleneTrianglesHaveNoEqualSides() throws TriangleException {
         Triangle triangle = new Triangle(3, 4, 5);
         assertEquals(TriangleKind.SCALENE, triangle.getKind());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void scaleneTrianglesHaveNoEqualSidesAtLargerScaleEither() throws TriangleException {
         Triangle triangle = new Triangle(10, 11, 12);
         assertEquals(TriangleKind.SCALENE, triangle.getKind());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void scaleneTrianglesHaveNoEqualSidesInDescendingOrderEither() throws TriangleException {
         Triangle triangle = new Triangle(5, 4, 2);
         assertEquals(TriangleKind.SCALENE, triangle.getKind());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void verySmallTrianglesAreLegal() throws TriangleException {
         Triangle triangle = new Triangle(0.4, 0.6, 0.3);
         assertEquals(TriangleKind.SCALENE, triangle.getKind());
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void trianglesWithNoSizeAreIllegal() throws TriangleException {
         thrown.expect(TriangleException.class);
         new Triangle(0, 0, 0);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void trianglesWithNegativeSidesAreIllegal() throws TriangleException {
         thrown.expect(TriangleException.class);
         new Triangle(3, 4, -5);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void trianglesViolatingTriangleInequalityAreIllegal() throws TriangleException {
         thrown.expect(TriangleException.class);
         new Triangle(1, 1, 3);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void trianglesViolatingTriangleInequalityAreIllegal2() throws TriangleException {
         thrown.expect(TriangleException.class);
         new Triangle(2, 4, 2);
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void trianglesViolatingTriangleInequalityAreIllegal3() throws TriangleException {
         thrown.expect(TriangleException.class);

exercises/twelve-days/src/test/java/TwelveDaysTest.java

         assertEquals(expectedVerseOne, twelveDays.verse(1));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testVerseTwo() {
         String expectedVerseTwo = "On the second day of Christmas my true love gave to me, two Turtle Doves, " +
         assertEquals(expectedVerseTwo, twelveDays.verse(2));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testVerseThree() {
         String expectedVerseThree = "On the third day of Christmas my true love gave to me, three French Hens, " +
         assertEquals(expectedVerseThree, twelveDays.verse(3));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testVerseFour() {
         String expectedVerseFour = "On the fourth day of Christmas my true love gave to me, four Calling Birds, " +
         assertEquals(expectedVerseFour, twelveDays.verse(4));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testVerseFive() {
         String expectedVerseFive = "On the fifth day of Christmas my true love gave to me, five Gold Rings, " +
         assertEquals(expectedVerseFive, twelveDays.verse(5));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testVerseSix() {
         String expectedVerseSix = "On the sixth day of Christmas my true love gave to me, six Geese-a-Laying, " +
         assertEquals(expectedVerseSix, twelveDays.verse(6));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testVerseSeven() {
         String expectedVerseSeven = "On the seventh day of Christmas my true love gave to me, " +
         assertEquals(expectedVerseSeven, twelveDays.verse(7));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testVerseEight() {
         String expectedVerseEight = "On the eighth day of Christmas my true love gave to me, eight Maids-a-Milking," +
         assertEquals(expectedVerseEight, twelveDays.verse(8));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testVerseNine() {
         String expectedVerseNine = "On the ninth day of Christmas my true love gave to me, nine Ladies Dancing, " +
         assertEquals(expectedVerseNine, twelveDays.verse(9));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testVerseTen() {
         String expectedVerseTen = "On the tenth day of Christmas my true love gave to me, ten Lords-a-Leaping, " +
         assertEquals(expectedVerseTen, twelveDays.verse(10));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testVerseEleven() {
         String expectedVerseEleven = "On the eleventh day of Christmas my true love gave to me, " +
         assertEquals(expectedVerseEleven, twelveDays.verse(11));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testVerseTwelve() {
         String expectedVerseTwelve = "On the twelfth day of Christmas my true love gave to me, " +
         assertEquals(expectedVerseTwelve, twelveDays.verse(12));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testMultipleVerses() {
         String expectedVerseOneToThree = "On the first day of Christmas my true love gave to me, " +
         assertEquals(expectedVerseOneToThree, twelveDays.verses(1, 3));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSingWholeSong() {
         String expectedSong = "On the first day of Christmas my true love gave to me, a Partridge in a Pear Tree.\n" +

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

         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void countOneOfEach() {
         expectedWordCount.put("one", 1);
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void countMultipleOccurences() {
         expectedWordCount.put("one", 1);
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void ignorePunctuation() {
         expectedWordCount.put("car", 1);
 
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void includeNumbers() {
         expectedWordCount.put("testing", 2);
         );
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void normalizeCase() {
         expectedWordCount.put("go", 3);

exercises/wordy/src/test/java/WordProblemSolverTest.java

         assertEquals(2, solver.solve("What is 1 plus 1?"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSingleAddition2() {
         assertEquals(55, solver.solve("What is 53 plus 2?"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSingleAdditionWithNegativeNumbers() {
         assertEquals(-11, solver.solve("What is -1 plus -10?"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSingleAdditionOfLargeNumbers() {
         assertEquals(45801, solver.solve("What is 123 plus 45678?"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSingleSubtraction() {
         assertEquals(16, solver.solve("What is 4 minus -12?"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSingleMultiplication() {
         assertEquals(-75, solver.solve("What is -3 multiplied by 25?"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSingleDivision() {
         assertEquals(-11, solver.solve("What is 33 divided by -3?"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testMultipleAdditions() {
         assertEquals(3, solver.solve("What is 1 plus 1 plus 1?"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testAdditionThenSubtraction() {
         assertEquals(8, solver.solve("What is 1 plus 5 minus -2?"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testMultipleSubtractions() {
         assertEquals(3, solver.solve("What is 20 minus 4 minus 13?"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testSubtractionThenAddition() {
         assertEquals(14, solver.solve("What is 17 minus 6 plus 3?"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testMultipleMultiplications() {
         assertEquals(-12, solver.solve("What is 2 multiplied by -2 multiplied by 3?"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testAdditionThenMultiplication() {
         assertEquals(-8, solver.solve("What is -3 plus 7 multiplied by -2?"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testMultipleDivisions() {
         assertEquals(2, solver.solve("What is -12 divided by 2 divided by -3?"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testUnknownOperation() {
         expectedException.expect(IllegalArgumentException.class);
         solver.solve("What is 52 cubed?");
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testInvalidQuestionFormat() {
         expectedException.expect(IllegalArgumentException.class);