Mark all but first test @Ignore in all exercises

- in journey test, remove @Ignores so that test runs exercise all tests.
- increase the verbosity of test logging to aide in seeing progress as
  tests are un@Ignored and solved.
- saving scripts used to make changes to all exercises.  These are the
  start of a library of scripts making such changes easier.
- make Gradle output more CI-friendly.

bin/journey-test.sh

 EXECPATH=$PWD
 XAPI_PID=""
 
+# Makes CI output easier to read
+TERM=dumb
+
 function on_exit() {
   echo ">>> on_exit()"
   if [ "$XAPI_PID" != "" ] ; then
   local EXERCISES=`cat config.json | jq '.problems []' --raw-output`
   local TOTAL_EXERCISES=`cat config.json | jq '.problems | length'`
   local CURRENT_EXERCISE_NUMBER=1
+  local TEMPFILE="${TMPDIR:-/tmp}/journey-test.sh-unignore_all_tests.txt"
 
   pushd ${EXERCISM_HOME} >/dev/null
   for EXERCISE in $EXERCISES; do
     $EXERCISM fetch java $EXERCISE
     cp -R -H $REPO_ROOT/exercises/$EXERCISE/src/example/java/* $EXERCISM_HOME/java/$EXERCISE/src/main/java/
     pushd $EXERCISM_HOME/java/$EXERCISE/ >/dev/null
+    for TESTFILE in `find . -name "*Test.java"`; do
+      sed 's/@Ignore//' $TESTFILE > "$TEMPFILE" && mv "$TEMPFILE" "$TESTFILE"
+    done
     gradle test
     popd >/dev/null
 

config.json

   "ignored": [
     "_template",
     ".gradle",
-    "docs"
+    "build",
+    "docs",
+    "gradle",
+    "scripts"
   ],
   "foregone": [
     "leap",

exercises/_template/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/accumulate/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/accumulate/src/test/java/AccumulateTest.java

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

exercises/acronym/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

 import org.junit.Test;
+import org.junit.Ignore;
 
 import static org.junit.Assert.assertEquals;
 
 public class AcronymTest {
 
+
     @Test
     public void fromTitleCasedPhrases() {
         final String phrase = "Portable Network Graphics";
         assertEquals(expected, Acronym.generate(phrase));
     }
 
+    @Ignore
     @Test
     public void fromOtherTitleCasedPhrases() {
         final String phrase = "Ruby on Rails";
         assertEquals(expected, Acronym.generate(phrase));
     }
 
+    @Ignore
     @Test
     public void fromInconsistentlyCasedPhrases() {
         final String phrase = "HyperText Markup Language";
         assertEquals(expected, Acronym.generate(phrase));
     }
 
+    @Ignore
     @Test
     public void fromPhrasesWithPunctuation() {
         final String phrase = "First In, First Out";
         assertEquals(expected, Acronym.generate(phrase));
     }
 
+    @Ignore
     @Test
     public void fromOtherPhrasesWithPunctuation() {
         final String phrase = "PHP: Hypertext Preprocessor";
         assertEquals(expected, Acronym.generate(phrase));
     }
 
+    @Ignore
     @Test
     public void fromPhrasesWithPunctuationAndSentenceCasing() {
         final String phrase = "Complementary metal-oxide semiconductor";
         assertEquals(expected, Acronym.generate(phrase));
     }
 
+    @Ignore
     @Test
     public void fromPhraseWithSingleLetterWord() {
         final String phrase = "Cat in a Hat";

exercises/allergies/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

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

exercises/anagram/build.gradle

   testCompile "junit:junit:4.10"
   testCompile "org.assertj:assertj-core:3.2.0"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

 import java.util.Arrays;
 import java.util.List;
 import org.junit.Test;
+import org.junit.Ignore;
 
 public class AnagramTest {
 
+
     @Test
     public void testNoMatches() {
         Anagram detector = new Anagram("diaper");
         assertThat(detector.match(Arrays.asList("hello", "world", "zombies", "pants"))).isEmpty();
     }
 
+    @Ignore
     @Test
     public void testSimpleAnagram() {
         Anagram detector = new Anagram("ant");
         assertThat(anagram).containsExactly("tan");
     }
 
+    @Ignore
     @Test
     public void testDetectMultipleAnagrams() {
         Anagram detector = new Anagram("master");
         assertThat(anagrams).contains("maters", "stream");
     }
 
+    @Ignore
     @Test
     public void testDoesNotConfuseDifferentDuplicates() {
         Anagram detector = new Anagram("galea");
         assertThat(anagrams).isEmpty();
     }
 
+    @Ignore
     @Test
     public void testIdenticalWordIsNotAnagram() {
         Anagram detector = new Anagram("corn");
         assertThat(anagrams).containsExactly("cron");
     }
 
+    @Ignore
     @Test
     public void testEliminateAnagramsWithSameChecksum() {
         Anagram detector = new Anagram("mass");
         assertThat(detector.match(Arrays.asList("last")).isEmpty());
     }
 
+    @Ignore
     @Test
     public void testEliminateAnagramSubsets() {
         Anagram detector = new Anagram("good");
         assertThat(detector.match(Arrays.asList("dog", "goody"))).isEmpty();
     }
 
+    @Ignore
     @Test
     public void testDetectAnagrams() {
         Anagram detector = new Anagram("listen");
         assertThat(anagrams).contains("inlets");
     }
 
+    @Ignore
     @Test
     public void testMultipleAnagrams() {
         Anagram detector = new Anagram("allergy");
         assertThat(anagrams).contains("gallery", "largely", "regally");
     }
 
+    @Ignore
     @Test
     public void testAnagramsAreCaseInsensitive() {
         Anagram detector = new Anagram("Orchestra");

exercises/atbash-cipher/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

 import org.junit.Test;
+import org.junit.Ignore;
 import org.junit.experimental.runners.Enclosed;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
             this.expectedOutput = expectedOutput;
         }
 
-        @Test
+
+    @Test
         public void test() {
             assertEquals(expectedOutput, Atbash.encode(input));
         }
             this.expectedOutput = expectedOutput;
         }
 
-        @Test
+        @Ignore
+    @Test
         public void test() {
             assertEquals(expectedOutput, Atbash.decode(input));
         }

exercises/beer-song/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

 import org.junit.Test;
+import org.junit.Ignore;
 
 import static org.junit.Assert.assertEquals;
 
 public class BeerSongTest {
 
+
     @Test
     public void singOneVerse() {
         assertEquals("8 bottles of beer on the wall, 8 bottles of beer.\nTake one down and pass it around, 7 bottles of beer on the wall.\n\n", BeerSong.verse(8));
 
     }
 
+    @Ignore
     @Test
     public void singMoreThanOneVerse() {
         assertEquals("8 bottles of beer on the wall, 8 bottles of beer.\nTake one down and pass it around, 7 bottles of beer on the wall.\n\n7 bottles of beer on the wall, 7 bottles of beer.\nTake one down and pass it around, 6 bottles of beer on the wall.\n\n6 bottles of beer on the wall, 6 bottles of beer.\nTake one down and pass it around, 5 bottles of beer on the wall.\n\n", BeerSong.sing(8,6));
         assertEquals("3 bottles of beer on the wall, 3 bottles of beer.\nTake one down and pass it around, 2 bottles of beer on the wall.\n\n2 bottles of beer on the wall, 2 bottles of beer.\nTake one down and pass it around, 1 bottle of beer on the wall.\n\n1 bottle of beer on the wall, 1 bottle of beer.\nTake it down and pass it around, no more bottles of beer on the wall.\n\nNo more bottles of beer on the wall, no more bottles of beer.\nGo to the store and buy some more, 99 bottles of beer on the wall.\n\n",BeerSong.sing(3,0));
     }
 
+    @Ignore
     @Test
     public void singEntireSong() {
         assertEquals("99 bottles of beer on the wall, 99 bottles of beer.\nTake one down and pass it around, 98 bottles of beer on the wall.\n\n" +
                 BeerSong.singSong());
     }
 
-}
+}

exercises/binary/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/binary/src/test/java/BinaryTest.java

 import org.junit.Test;
+import org.junit.Ignore;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
         this.expectedOutput = expectedOutput;
     }
 
+
     @Test
     public void test() {
         Binary binary = new Binary(input);

exercises/bob/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/bob/src/test/java/BobTest.java

 import org.junit.Test;
+import org.junit.Ignore;
 
 import static org.junit.Assert.*;
 
 public class BobTest {
     private final Bob bob = new Bob();
 
+
     @Test
     public void saySomething() {
         assertEquals(
         );
     }
 
+    @Ignore
     @Test
     public void shouting() {
         assertEquals(
         );
     }
 
+    @Ignore
     @Test
     public void askingAQuestion() {
         assertEquals(
         );
     }
 
+    @Ignore
     @Test
     public void askingANumericQuestion() {
         assertEquals(
         );
     }
 
+    @Ignore
     @Test
     public void talkingForcefully() {
         assertEquals(
         );
     }
 
+    @Ignore
     @Test
     public void usingAcronymsInRegularSpeech() {
         assertEquals(
         );
     }
 
+    @Ignore
     @Test
     public void forcefulQuestions() {
         assertEquals(
         );
     }
 
+    @Ignore
     @Test
     public void shoutingNumbers() {
         assertEquals(
         );
     }
 
+    @Ignore
     @Test
     public void onlyNumbers() {
         assertEquals(
         );
     }
 
+    @Ignore
     @Test
     public void questionWithOnlyNumbers() {
         assertEquals(
         );
     }
 
+    @Ignore
     @Test
     public void shoutingWithSpecialCharacters() {
         assertEquals(
         );
     }
 
+    @Ignore
     @Test
     public void shoutingWithUmlauts() {
         assertEquals(
         );
     }
 
+    @Ignore
     @Test
     public void calmlySpeakingWithUmlauts() {
         assertEquals(
         );
     }
 
+    @Ignore
     @Test
     public void shoutingWithNoExclamationMark() {
         assertEquals(
         );
     }
 
+    @Ignore
     @Test
     public void statementContainingQuestionMark() {
         assertEquals(
         );
     }
 
+    @Ignore
     @Test
     public void prattlingOn() {
         assertEquals(
         );
     }
 
+    @Ignore
     @Test
     public void silence() {
         assertEquals(
         );
     }
 
+    @Ignore
     @Test
     public void prolongedSilence() {
         assertEquals(

exercises/build.gradle

     from "src/test/java"
     into "build/gen/test/java"
     filter { line ->
-      line.contains("@Ignore") ? null : line
+      line.contains("@Ignore") ? "" : line
     }
   }
 

exercises/crypto-square/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/crypto-square/src/test/java/CryptoSquareTest.java

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

exercises/etl/build.gradle

   testCompile "org.assertj:assertj-core:3.2.0"
   testCompile "com.google.guava:guava:16+"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

 import com.google.common.collect.ImmutableMap;
 import org.junit.Test;
+import org.junit.Ignore;
 
 import java.util.Arrays;
 import java.util.List;
 public class EtlTest {
     private final Etl etl = new Etl();
 
+
     @Test
     public void testTransformOneValue() {
         Map<Integer, List<String>> old = ImmutableMap.of(1, Arrays.asList("A"));
         assertThat(etl.transform(old)).isEqualTo(expected);
     }
 
+    @Ignore
     @Test
     public void testTransformMoreValues() {
         Map<Integer, List<String>> old = ImmutableMap.of(
         assertThat(etl.transform(old)).isEqualTo(expected);
     }
 
+    @Ignore
     @Test
     public void testMoreKeys() {
         Map<Integer, List<String>> old = ImmutableMap.of(
         assertThat(etl.transform(old)).isEqualTo(expected);
     }
 
+    @Ignore
     @Test
     public void testFullDataset() {
         Map<Integer, List<String>> old = ImmutableMap.<Integer, List<String>>builder().

exercises/gigasecond/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

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

exercises/grade-school/build.gradle

   testCompile "junit:junit:4.10"
   testCompile "org.assertj:assertj-core:3.2.0"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

 import static org.assertj.core.api.Assertions.assertThat;
 
 import org.junit.Test;
+import org.junit.Ignore;
 
 import java.util.Arrays;
 import java.util.HashMap;
 public class SchoolTest {
   private final School school = new School();
 
-  @Test
+
+    @Test
   public void startsWithNoStudents() {
     assertThat(school.db()).isEmpty();
   }
 
-  @Test
+  @Ignore
+    @Test
   public void addsStudents() {
     school.add("Aimee", 2);
     assertThat(school.db().get(2)).contains("Aimee");
   }
 
-  @Test
+  @Ignore
+    @Test
   public void addsMoreStudentsInSameGrade() {
     final int grade = 2;
     school.add("James", grade);
     assertThat(school.db().get(grade)).hasSize(3).contains("James", "Blair", "Paul");
   }
 
-  @Test
+  @Ignore
+    @Test
   public void addsStudentsInMultipleGrades() {
     school.add("Chelsea", 3);
     school.add("Logan", 7);
     assertThat(school.db().get(7)).hasSize(1).contains("Logan");
   }
 
-  @Test
+  @Ignore
+    @Test
   public void getsStudentsInAGrade() {
     school.add("Franklin", 5);
     school.add("Bradley", 5);
     assertThat(school.grade(5)).hasSize(2).contains("Franklin", "Bradley");
   }
 
-  @Test
+  @Ignore
+    @Test
   public void getsStudentsInEmptyGrade() {
     assertThat(school.grade(1)).isEmpty();
   }
 
-  @Test
+  @Ignore
+    @Test
   public void sortsSchool() {
     school.add("Jennifer", 4);
     school.add("Kareem", 6);

exercises/hamming/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

 import static org.junit.Assert.*;
 
 import org.junit.Test;
+import org.junit.Ignore;
 
 public class HammingTest {
     
+
     @Test
     public void testNoDifferenceBetweenIdenticalStrands() {
         assertThat(Hamming.compute("A", "A"), is(0));
     }
 
+    @Ignore
     @Test
     public void testCompleteHammingDistanceOfForSingleNucleotideStrand() {
         assertThat(Hamming.compute("A", "G"), is(1));
     }
 
+    @Ignore
     @Test
     public void testCompleteHammingDistanceForSmallStrand() {
         assertThat(Hamming.compute("AG", "CT"), is(2)); 
     }
 
+    @Ignore
     @Test
     public void testSmallHammingDistance() {
         assertThat(Hamming.compute("AT", "CT"), is(1));
     }
 
+    @Ignore
     @Test
     public void testSmallHammingDistanceInLongerStrand() {
         assertThat(Hamming.compute("GGACG", "GGTCG"), is(1));
     }
 
+    @Ignore
     @Test(expected = IllegalArgumentException.class)
     public void testValidatesFirstStrandNotLonger() {
         Hamming.compute("AAAG", "AAA");
     }
 
+    @Ignore
     @Test(expected = IllegalArgumentException.class)
     public void testValidatesOtherStrandNotLonger() {
         Hamming.compute("AAA", "AAAG");
     }
 
+    @Ignore
     @Test
     public void testLargeHammingDistance() {
         assertThat(Hamming.compute("GATACA", "GCATAA"), is(4));
     }
 
+    @Ignore
     @Test
     public void testHammingDistanceInVeryLongStrand() {
         assertThat(Hamming.compute("GGACGGATTCTG", "AGGACGGATTCT"), is(9));

exercises/hello-world/build.gradle

     events = ["passed", "failed", "skipped"]
   }
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/hello-world/src/test/java/HelloWorldTest.java

 import org.junit.Test;
 import org.junit.Ignore;
+import org.junit.Ignore;
 
 import static org.junit.Assert.assertEquals;
 
 public class HelloWorldTest {
 
+
     @Test
     public void helloNoName() {
         assertEquals("Hello, World!", HelloWorld.hello(""));

exercises/hexadecimal/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/hexadecimal/src/test/java/HexadecimalTest.java

 import org.junit.Test;
+import org.junit.Ignore;
 import static org.junit.Assert.assertEquals;
 
 public class HexadecimalTest {
 
+
     @Test
     public void testOne(){
         int expected = 1;
         assertEquals(expected, Hexadecimal.toDecimal("1"));
     }
 
+    @Ignore
     @Test
     public void testC(){
         int expected = 12;
         assertEquals(expected, Hexadecimal.toDecimal("c"));
     }
 
+    @Ignore
     @Test
     public void test10(){
         int expected = 16;
         assertEquals(expected, Hexadecimal.toDecimal("10"));
     }
 
+    @Ignore
     @Test
     public void testAf(){
         int expected = 175;
         assertEquals(expected, Hexadecimal.toDecimal("af"));
     }
 
+    @Ignore
     @Test
     public void test100(){
         int expected = 256;
         assertEquals(expected, Hexadecimal.toDecimal("100"));
     }
 
+    @Ignore
     @Test
     public void test19ace(){
         int expected = 105166;
         assertEquals(expected, Hexadecimal.toDecimal("19ace"));
     }
 
+    @Ignore
     @Test
     public void testInvalid(){
         int expected = 0;
         assertEquals(expected, Hexadecimal.toDecimal("carrot"));
     }
 
+    @Ignore
     @Test
     public void testBlack(){
         int expected = 0;
         assertEquals(expected, Hexadecimal.toDecimal("000000"));
     }
 
+    @Ignore
     @Test
     public void testWhite(){
         int expected = 16777215;
         assertEquals(expected, Hexadecimal.toDecimal("ffffff"));
     }
 
+    @Ignore
     @Test
     public void testYellow(){
         int expected = 16776960;

exercises/linked-list/build.gradle

   testCompile "junit:junit:4.10"
   testCompile "org.assertj:assertj-core:3.2.0"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

 import org.junit.Before;
 import org.junit.Test;
+import org.junit.Ignore;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
         subject = new Deque<>();
     }
 
+
     @Test
     public void testPushPop() {
         subject.push(10);
         assertThat(subject.pop()).isEqualTo(10);
     }
 
+    @Ignore
     @Test
     public void testPushShift() {
         subject.push(10);
         assertThat(subject.shift()).isEqualTo(20);
     }
 
+    @Ignore
     @Test
     public void testUnshiftShift() {
         subject.unshift(10);
         assertThat(subject.shift()).isEqualTo(10);
     }
 
+    @Ignore
     @Test
     public void testUnshiftPop() {
         subject.unshift(10);
         assertThat(subject.pop()).isEqualTo(20);
     }
 
+    @Ignore
     @Test
     public void testExample() {
         subject.push(10);

exercises/luhn/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/luhn/src/test/java/LuhnTest.java

 import org.junit.Test;
+import org.junit.Ignore;
 
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 
 public class LuhnTest {
 
+
     @Test
     public void checkDigitIsRightMostDigit() {
         Luhn luhn = new Luhn(34567);
         assertEquals(expectedOutput, luhn.getCheckDigit());
     }
 
+    @Ignore
     @Test
     public void addendsDoublesEveryOtherNumberFromRight() {
         Luhn luhn = new Luhn(12121);
         assertArrayEquals(expectedOutput, luhn.getAddends());
     }
 
+    @Ignore
     @Test
     public void addendsSubtracts9WhenDoubledNumberIsMoreThan9() {
         Luhn luhn = new Luhn(8631);
         assertArrayEquals(expectedOutput, luhn.getAddends());
     }
 
+    @Ignore
     @Test
     public void checkSumAddsAddendsTogether1() {
         Luhn luhn = new Luhn(4913);
         assertEquals(expectedOutput, luhn.getCheckSum());
     }
 
+    @Ignore
     @Test
     public void checkSumAddsAddendsTogether2() {
         Luhn luhn = new Luhn(201773);
         assertEquals(expectedOutput, luhn.getCheckSum());
     }
 
+    @Ignore
     @Test
     public void numberIsValidWhenChecksumMod10IsZero1() {
         Luhn luhn = new Luhn(738);
         assertEquals(expectedOutput, luhn.isValid());
     }
 
+    @Ignore
     @Test
     public void numberIsValidWhenChecksumMod10IsZero2() {
         Luhn luhn = new Luhn(8739567);
         assertEquals(expectedOutput, luhn.isValid());
     }
 
+    @Ignore
     @Test
     public void luhnCanCreateSimpleNumbersWithValidCheckDigit() {
         long expectedOutput = 1230;
         assertEquals(expectedOutput, Luhn.create(123));
     }
 
+    @Ignore
     @Test
     public void luhnCanCreateLargeNumbersWithValidCheckDigit() {
         long expectedOutput = 8739567;
         assertEquals(expectedOutput, Luhn.create(873956));
     }
 
+    @Ignore
     @Test
     public void luhnCanCreateHugeNumbersWithValidCheckDigit() {
         long expectedOutput = 8372637564L;

exercises/meetup/build.gradle

   testCompile "junit:junit:4.10"
   testCompile "org.assertj:assertj-core:3.2.0"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

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

exercises/nth-prime/build.gradle

   testCompile "junit:junit:4.10"
   testCompile "org.assertj:assertj-core:3.2.0"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

 import org.junit.Test;
+import org.junit.Ignore;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class PrimeTest {
+
     @Test
     public void testFirstPrime() {
         assertThat(Prime.nth(1)).isEqualTo(2);
     }
 
+    @Ignore
     @Test
     public void testSecondPrime() {
         assertThat(Prime.nth(2)).isEqualTo(3);
     }
 
+    @Ignore
     @Test
     public void testSixthPrime() {
         assertThat(Prime.nth(6)).isEqualTo(13);
     }
 
+    @Ignore
     @Test
     public void testBigPrime() {
         assertThat(Prime.nth(10001)).isEqualTo(104743);
     }
 
+    @Ignore
     @Test(expected = IllegalArgumentException.class)
     public void testUndefinedPrime() {
         Prime.nth(0);

exercises/nucleotide-count/build.gradle

   testCompile "org.assertj:assertj-core:3.2.0"
 }
 
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

 import static org.assertj.core.api.Assertions.entry;
 
 import org.junit.Test;
+import org.junit.Ignore;
 
 public class NucleotideTest {
-  @Test
+
+    @Test
   public void testEmptyDnaStringHasNoAdenosine() {
     DNA dna = new DNA("");
     assertThat(dna.count('A')).isEqualTo(0);
   }
 
-  @Test
+  @Ignore
+    @Test
   public void testEmptyDnaStringHasNoNucleotides() {
     DNA dna = new DNA("");
     assertThat(dna.nucleotideCounts()).hasSize(4).contains(
     );
   }
 
-  @Test
+  @Ignore
+    @Test
   public void testRepetitiveCytidineGetsCounted() {
     DNA dna = new DNA("CCCCC");
     assertThat(dna.count('C')).isEqualTo(5);
   }
 
-  @Test
+  @Ignore
+    @Test
   public void testRepetitiveSequenceWithOnlyGuanosine() {
     DNA dna = new DNA("GGGGGGGG");
     assertThat(dna.nucleotideCounts()).hasSize(4).contains(
     );
   }
 
-  @Test
+  @Ignore
+    @Test
   public void testCountsOnlyThymidine() {
     DNA dna = new DNA("GGGGGTAACCCGG");
     assertThat(dna.count('T')).isEqualTo(1);
   }
 
-  @Test
+  @Ignore
+    @Test
   public void testCountsANucleotideOnlyOnce() {
     DNA dna = new DNA("CGATTGGG");
     dna.count('T');
     assertThat(dna.count('T')).isEqualTo(2);
   }
 
-  @Test
+  @Ignore
+    @Test
   public void testDnaCountsDoNotChangeAfterCountingAdenosine() {
     DNA dna = new DNA("GATTACA");
     dna.count('A');
     );
   }
 
-  @Test(expected = IllegalArgumentException.class)
+  @Ignore
+    @Test(expected = IllegalArgumentException.class)
   public void testValidatesNucleotides() {
     DNA dna = new DNA("GACT");
     dna.count('X');
   }
 
-  @Test
+  @Ignore
+    @Test
   public void testCountsAllNucleotides() {
     String s = "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC";
     DNA dna = new DNA(s);

exercises/octal/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/octal/src/test/java/OctalTest.java

 import org.junit.Test;
+import org.junit.Ignore;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
         this.expectedOutput = expectedOutput;
     }
 
+
     @Test
     public void test() {
         Octal octal = new Octal(input);

exercises/pangram/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/pangram/src/test/java/PangramTest.java

 import org.junit.Test;
+import org.junit.Ignore;
 
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.assertFalse;
 
 public class PangramTest {
 
+
     @Test
     public void emptySentence() {
         assertFalse(Pangrams.isPangram(""));
     }
 
+    @Ignore
     @Test
     public void testLowercasePangram() {
         assertTrue(Pangrams.isPangram("the quick brown fox jumps over the lazy dog"));
     }
 
+    @Ignore
     @Test
     public void missingCharacterX() {
         assertFalse(Pangrams.isPangram("a quick movement of the enemy will jeopardize five gunboats"));
     }
 
+    @Ignore
     @Test
     public void mixedCaseAndPunctuation() {
         assertTrue(Pangrams.isPangram("\"Five quacking Zephyrs jolt my wax bed.\""));
     }
 
+    @Ignore
     @Test
     public void nonAsciiCharacters() {
         assertTrue(Pangrams.isPangram("Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich."));

exercises/pascals-triangle/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

 import org.junit.Test;
+import org.junit.Ignore;
 
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 
 public class PascalsTriangleTest {
 
+
     @Test
     public void testTriangleWithFourRows() {
         int[][] expectedOutput = new int[][]{
         assertArrayEquals(expectedOutput, PascalsTriangle.computeTriangle(4));
     }
 
+    @Ignore
     @Test
     public void testTriangleWithSixRows() {
         int[][] expectedOutput = new int[][]{
         assertArrayEquals(expectedOutput, PascalsTriangle.computeTriangle(6));
     }
 
+    @Ignore
     @Test
     public void testExpectEmptyTriangle() {
         int[][] expectedOutput = new int[][]{
         assertArrayEquals(expectedOutput, PascalsTriangle.computeTriangle(0));
     }
 
+    @Ignore
     @Test
     public void testValidInput() {
         int[][] input = new int[][]{
         assertEquals(true, PascalsTriangle.isTriangle(input));
     }
 
+    @Ignore
     @Test
     public void testInvalidInput() {
         int[][] input = new int[][]{
         assertEquals(false, PascalsTriangle.isTriangle(input));
     }
 
+    @Ignore
     @Test(expected = IllegalArgumentException.class)
     public void testValidatesNotNegativeRows() {
         PascalsTriangle.computeTriangle(-1);

exercises/phone-number/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

 import org.junit.Test;
+import org.junit.Ignore;
 
 import static org.junit.Assert.*;
 
 public class PhoneNumberTest {
 
+
     @Test
     public void cleansNumber() {
         final String expectedNumber = "1234567890";
         );
     }
 
+    @Ignore
     @Test
     public void cleansNumberWithDots() {
         final String expectedNumber = "1234567890";
         );
     }
 
+    @Ignore
     @Test
     public void validWhen11DigitsAndFirstIs1() {
         final String expectedNumber = "1234567890";
         );
     }
 
+    @Ignore
     @Test
     public void invalidWhenOnly11Digits() {
         final String expectedNumber = "0000000000";
         );
     }
 
+    @Ignore
     @Test
     public void invalidWhen9Digits() {
         final String expectedNumber = "0000000000";
         );
     }
 
+    @Ignore
     @Test
     public void areaCode() {
         final String expectedAreaCode = "123";
         );
     }
 
+    @Ignore
     @Test
     public void prettyPrint() {
         final String expectedPrettyNumber = "(123) 456-7890";
         );
     }
 
+    @Ignore
     @Test
     public void prettyPrintWithFullUSPhoneNumber() {
         final String expectedPrettyNumber = "(123) 456-7890";

exercises/pig-latin/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/pig-latin/src/test/java/PigLatinTest.java

 import org.junit.Test;
+import org.junit.Ignore;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
         this.expectedOutput = expectedOutput;
     }
 
+
     @Test
     public void test() {
         assertEquals(expectedOutput, PigLatin.translate(input));

exercises/prime-factors/build.gradle

   testCompile "junit:junit:4.12"
 }
 
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/prime-factors/src/test/java/PrimeFactorsTest.java

 import org.junit.Test;
+import org.junit.Ignore;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
         this.expectedOutput = expectedOutput;
     }
 
+
     @Test
     public void test() {
         assertEquals(expectedOutput, PrimeFactors.getForNumber(input));

exercises/raindrops/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/raindrops/src/test/java/RaindropsTest.java

 import org.junit.Test;
+import org.junit.Ignore;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
         this.expectedOutput = expectedOutput;
     }
 
+
     @Test
     public void test() {
         assertEquals(expectedOutput, Raindrops.convert(input));

exercises/rna-transcription/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/rna-transcription/src/test/java/RnaTranscriptionTest.java

 import org.junit.Assert;
 import org.junit.Test;
+import org.junit.Ignore;
 
 public class RnaTranscriptionTest {
 
+
     @Test
     public void testRnaTranscriptionOfEmptyDnaIsEmptyRna() {
         Assert.assertEquals("", RnaTranscription.ofDna(""));
     }
 
+    @Ignore
     @Test
     public void testRnaTranscriptionOfCytosineIsGuanine() {
         Assert.assertEquals("G", RnaTranscription.ofDna("C"));
     }
 
+    @Ignore
     @Test
     public void testRnaTranscriptionOfGuanineIsCytosine() {
         Assert.assertEquals("C", RnaTranscription.ofDna("G"));
     }
 
+    @Ignore
     @Test
     public void testRnaTranscriptionOfThymineIsAdenine() {
         Assert.assertEquals("A", RnaTranscription.ofDna("T"));
     }
 
+    @Ignore
     @Test
     public void testRnaTranscriptionOfAdenineIsUracil() {
         Assert.assertEquals("U", RnaTranscription.ofDna("A"));
     }
 
+    @Ignore
     @Test
     public void testRnaTranscription() {
         Assert.assertEquals("UGCACCAGAAUU", RnaTranscription.ofDna("ACGTGGTCTTAA"));

exercises/robot-name/build.gradle

   testCompile "junit:junit:4.10"
 }
 
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

 import org.junit.Test;
+import org.junit.Ignore;
 
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.core.Is.is;
     private static final String EXPECTED_ROBOT_NAME_PATTERN = "[A-Z]{2}\\d{3}";
     private final Robot robot = new Robot();
 
+
     @Test
     public void hasName() {
         assertIsValidName(robot.getName());
     }
 
+    @Ignore
     @Test
     public void differentRobotsHaveDifferentNames() {
         assertThat(robot.getName(), not(equalTo(new Robot().getName())));
     }
 
+    @Ignore
     @Test
     public void resetName() {
         final String name = robot.getName();

exercises/roman-numerals/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/roman-numerals/src/test/java/RomanNumeralsTest.java

 import org.junit.Test;
+import org.junit.Ignore;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
         this.expectedOutput = expectedOutput;
     }
 
+
     @Test
     public void convertArabicNumberalToRomanNumeral() {
         RomanNumeral romanNumeral = new RomanNumeral(input);

exercises/scrabble-score/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/scrabble-score/src/test/java/ScrabbleScoreTest.java

 import org.junit.Test;
+import org.junit.Ignore;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
         this.expectedOutput = expectedOutput;
     }
 
+
     @Test
     public void test() {
         Scrabble scrabble = new Scrabble(input);

exercises/sieve/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

 import org.junit.Test;
+import org.junit.Ignore;
 
 import java.util.Arrays;
 import java.util.List;
 
 public class SieveTest {
 
+
     @Test
     public void findFirstPrime() {
         Sieve sieve = new Sieve(2);
         assertEquals(expectedOutput, sieve.getPrimes());
     }
 
+    @Ignore
     @Test
     public void findPrimesUpTo10() {
         Sieve sieve = new Sieve(10);
         assertEquals(expectedOutput, sieve.getPrimes());
     }
 
+    @Ignore
     @Test
     public void findPrimesUpTo1000() {
         Sieve sieve = new Sieve(1000);

exercises/simple-cipher/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

 import org.junit.Test;
+import org.junit.Ignore;
 
 public class IncorrectKeyCipherTest {
 
+
     @Test(expected = IllegalArgumentException.class)
     public void cipherThrowsWithAllCapsKey() {
         new Cipher("ABCDEF");
     }
 
+    @Ignore
     @Test(expected = IllegalArgumentException.class)
     public void cipherThrowsWithAnyCapsKey() {
         new Cipher("abcdEFg");
     }
 
+    @Ignore
     @Test(expected = IllegalArgumentException.class)
     public void cipherThrowsWithNumericKey() {
         new Cipher("12345");
     }
 
+    @Ignore
     @Test(expected = IllegalArgumentException.class)
     public void cipherThrowsWithAnyNumericKey() {
         new Cipher("abcd345ef");
     }
 
+    @Ignore
     @Test(expected = IllegalArgumentException.class)
     public void cipherThrowsWithEmptyKey() {
         new Cipher("");

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

 import org.junit.Before;
 import org.junit.Test;
+import org.junit.Ignore;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
         this.cipher = new Cipher();
     }
 
+
     @Test
     public void cipherKeyIsMadeOfLetters() {
         assertTrue(cipher.getKey().matches("[a-z]+"));
     }
 
+    @Ignore
     @Test
     public void defaultCipherKeyIs100Characters() {
         assertEquals(100, cipher.getKey().length());
     }
 
+    @Ignore
     @Test
     public void cipherKeysAreRandomlyGenerated() {
         assertTrue(!(new Cipher().getKey().equals(cipher.getKey())));
      * Here we take advantage of the fact that plaintext of "aaa..." doesn't output the key. This is a critical problem
      * with shift ciphers, some characters will always output the key verbatim.
      */
+    @Ignore
     @Test
     public void cipherCanEncode() {
         String expectedOutput = cipher.getKey().substring(0, 10);
         assertEquals(expectedOutput, cipher.encode("aaaaaaaaaa"));
     }
 
+    @Ignore
     @Test
     public void cipherCanDecode() {
         String expectedOutput = "aaaaaaaaaa";
         assertEquals(expectedOutput, cipher.decode(cipher.getKey().substring(0, 10)));
     }
 
+    @Ignore
     @Test
     public void cipherIsReversible() {
         String plainText = "abcdefghij";

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

 import org.junit.Before;
 import org.junit.Test;
+import org.junit.Ignore;
 
 import static org.junit.Assert.assertEquals;
 
         this.cipher = new Cipher(KEY);
     }
 
+
     @Test
     public void cipherKeepsTheSubmittedKey() {
         assertEquals(KEY, cipher.getKey());
     }
 
+    @Ignore
     @Test
     public void cipherCanEncodeWithGivenKey() {
         String expectedOutput = "abcdefghij";
         assertEquals(expectedOutput, cipher.encode("aaaaaaaaaa"));
     }
 
+    @Ignore
     @Test
     public void cipherCanDecodeWithGivenKey() {
         String expectedOutput = "aaaaaaaaaa";
         assertEquals(expectedOutput, cipher.decode("abcdefghij"));
     }
 
+    @Ignore
     @Test
     public void cipherIsReversibleGivenKey() {
         String plainText = "abcdefghij";
         assertEquals(plainText, cipher.decode(cipher.encode("abcdefghij")));
     }
 
+    @Ignore
     @Test
     public void cipherCanDoubleShiftEncode() {
         String plainText = "iamapandabear";
         assertEquals(expectedOutput, new Cipher(plainText).encode(plainText));
     }
 
+    @Ignore
     @Test
     public void cipherCanWrapEncode() {
         String expectedOutput = "zabcdefghi";
         assertEquals(expectedOutput, cipher.encode("zzzzzzzzzz"));
     }
 
+    @Ignore
     @Test
     public void cipherCanEncodeMessageThatIsShorterThanTheKey() {
         String expectedOutput = "abcde";
         assertEquals(expectedOutput, cipher.encode("aaaaa"));
     }
 
+    @Ignore
     @Test
     public void cipherCanDecodeMessageThatIsShorterThanTheKey() {
         String expectedOutput = "aaaaa";

exercises/simple-linked-list/build.gradle

   testCompile "junit:junit:4.10"
   testCompile "org.assertj:assertj-core:3.2.0"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/simple-linked-list/src/test/java/SimpleLinkedListTest.java

 import java.util.NoSuchElementException;
 import static org.assertj.core.api.Assertions.assertThat;
 import org.junit.Test;
+import org.junit.Ignore;
 
 public class SimpleLinkedListTest {
 
+
     @Test
     public void aNewListIsEmpty() {
         SimpleLinkedList list = new SimpleLinkedList();
         assertThat(list.size()).isEqualTo(0);
     }
 
+    @Ignore
     @Test
     public void canCreateFromArray() {
         Integer[] values = new Integer[]{1, 2, 3};
         assertThat(list.size()).isEqualTo(3);
     }
 
+    @Ignore
     @Test(expected = NoSuchElementException.class)
     public void popOnEmptyListWillThrow() {
         SimpleLinkedList list = new SimpleLinkedList();
         list.pop();
     }
 
+    @Ignore
     @Test
     public void popReturnsLastAddedElement() {
         SimpleLinkedList list = new SimpleLinkedList();
         assertThat(list.size()).isEqualTo(0);
     }
 
+    @Ignore
     @Test
     public void reverseReversesList() {
         SimpleLinkedList list = new SimpleLinkedList();
         assertThat(list.pop()).isEqualTo(5);
     }
 
+    @Ignore
     @Test
     public void canReturnListAsArray() {
         SimpleLinkedList list = new SimpleLinkedList();
         assertThat(list.asArray(Integer.class)).containsExactly(expected);
     }
 
+    @Ignore
     @Test
     public void canReturnEmptyListAsEmptyArray() {
         SimpleLinkedList list = new SimpleLinkedList();

exercises/space-age/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/space-age/src/test/java/SpaceAgeTest.java

 import org.junit.Test;
+import org.junit.Ignore;
 
 import static org.junit.Assert.assertEquals;
 
 
     private static final double MAXIMUM_DELTA = 1E-02;
 
+
     @Test
     public void ageInSeconds() {
         SpaceAge age = new SpaceAge(1000000);
         assertEquals(1000000, age.getSeconds(), MAXIMUM_DELTA);
     }
 
+    @Ignore
     @Test
     public void ageOnEarth() {
         SpaceAge age = new SpaceAge(1000000000);
         assertEquals(31.69, age.onEarth(), MAXIMUM_DELTA);
     }
 
+    @Ignore
     @Test
     public void ageOnMercury() {
         SpaceAge age = new SpaceAge(2134835688);
         assertEquals(280.88, age.onMercury(), MAXIMUM_DELTA);
     }
 
+    @Ignore
     @Test
     public void ageOnVenus() {
         SpaceAge age = new SpaceAge(189839836);
         assertEquals(9.78, age.onVenus(), MAXIMUM_DELTA);
     }
 
+    @Ignore
     @Test
     public void ageOnMars() {
         SpaceAge age = new SpaceAge(2329871239L);
         assertEquals(39.25, age.onMars(), MAXIMUM_DELTA);
     }
 
+    @Ignore
     @Test
     public void ageOnJupiter() {
         SpaceAge age = new SpaceAge(901876382);
         assertEquals(2.41, age.onJupiter(), MAXIMUM_DELTA);
     }
 
+    @Ignore
     @Test
     public void ageOnSaturn() {
         SpaceAge age = new SpaceAge(3000000000L);
         assertEquals(3.23, age.onSaturn(), MAXIMUM_DELTA);
     }
 
+    @Ignore
     @Test
     public void ageOnUranus() {
         SpaceAge age = new SpaceAge(3210123456L);
         assertEquals(1.21, age.onUranus(), MAXIMUM_DELTA);
     }
 
+    @Ignore
     @Test
     public void ageOnNeptune() {
         SpaceAge age = new SpaceAge(8210123456L);

exercises/strain/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/strain/src/test/java/StrainTest.java

 import org.junit.Assert;
 import org.junit.Test;
+import org.junit.Ignore;
 
 import java.util.Arrays;
 import java.util.LinkedList;
 
 public class StrainTest {
 
+
     @Test
     public void emptyKeep() {
         List<Integer> input = new LinkedList<>();
         Assert.assertEquals(expectedOutput, Strain.keep(input, x -> x < 10));
     }
 
+    @Ignore
     @Test
     public void keepEverything() {
         List<Integer> input = Arrays.asList(1, 2, 3);
         Assert.assertEquals(expectedOutput, Strain.keep(input, x -> x < 10));
     }
 
+    @Ignore
     @Test
     public void keepFirstAndLast() {
         List<Integer> input = Arrays.asList(1, 2, 3);
         Assert.assertEquals(expectedOutput, Strain.keep(input, x -> x % 2 != 0));
     }
 
+    @Ignore
     @Test
     public void keepNeitherFirstNorLast() {
         List<Integer> input = Arrays.asList(1, 2, 3, 4, 5);
         Assert.assertEquals(expectedOutput, Strain.keep(input, x -> x % 2 == 0));
     }
 
+    @Ignore
     @Test
     public void KeepStrings() {
         List<String> words = Arrays
                 Strain.keep(words, x -> x.startsWith("z")));
     }
 
+    @Ignore
     @Test
     public void KeepArrays() {
         List<List<Integer>> actual = Arrays.asList(
                 Strain.keep(actual, col -> col.contains(5)));
     }
 
+    @Ignore
     @Test
     public void emptyDiscard() {
         List<Integer> input = new LinkedList<>();
         Assert.assertEquals(expectedOutput, Strain.discard(input, x -> x < 10));
     }
 
+    @Ignore
     @Test
     public void discardNothing() {
         List<Integer> input = Arrays.asList(1, 2, 3);
         Assert.assertEquals(expectedOutput, Strain.discard(input, x -> x > 10));
     }
 
+    @Ignore
     @Test
     public void discardFirstAndLast() {
         List<Integer> input = Arrays.asList(1, 2, 3);
 
     }
 
+    @Ignore
     @Test
     public void discardNeitherFirstNorLast() {
         List<Integer> input = Arrays.asList(1, 2, 3, 4, 5);
         Assert.assertEquals(expectedOutput, Strain.discard(input, x -> x % 2 == 0));
     }
 
+    @Ignore
     @Test
     public void discardStrings() {
         List<String> words = Arrays
                 Strain.discard(words, x -> x.startsWith("z")));
     }
 
+    @Ignore
     @Test
     public void discardArrays() {
         List<List<Integer>> actual = Arrays.asList(

exercises/triangle/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

 import org.junit.Test;
+import org.junit.Ignore;
 
 import static org.junit.Assert.assertEquals;
 
 public class TriangleTest {
 
+
     @Test
     public void equilateralTriangleHaveEqualSides() throws Exception {
         Triangle triangle = new Triangle(2, 2, 2);
         assertEquals(TriangleKind.EQUILATERAL, triangle.getKind());
     }
 
+    @Ignore
     @Test
     public void largerEquilateralTrianglesAlsoHaveEqualSides() throws Exception {
         Triangle triangle = new Triangle(10, 10, 10);
         assertEquals(TriangleKind.EQUILATERAL, triangle.getKind());
     }
 
+    @Ignore
     @Test
     public void isoscelesTrianglesHaveLastTwoSidesEqual() throws Exception {
         Triangle triangle = new Triangle(3, 4, 4);
         assertEquals(TriangleKind.ISOSCELES, triangle.getKind());
     }
 
+    @Ignore
     @Test
     public void isoscelesTrianglesHaveFirstAndLastSidesEqual() throws Exception {
         Triangle triangle = new Triangle(4, 3, 4);
         assertEquals(TriangleKind.ISOSCELES, triangle.getKind());
     }
 
+    @Ignore
     @Test
     public void isoscelesTrianglesHaveTwoFirstSidesEqual() throws Exception {
         Triangle triangle = new Triangle(4, 4, 3);
         assertEquals(TriangleKind.ISOSCELES, triangle.getKind());
     }
 
+    @Ignore
     @Test
     public void isoscelesTrianglesHaveInFactExactlyTwoSidesEqual() throws Exception {
         Triangle triangle = new Triangle(10, 10, 2);
         assertEquals(TriangleKind.ISOSCELES, triangle.getKind());
     }
 
+    @Ignore
     @Test
     public void scaleneTrianglesHaveNoEqualSides() throws Exception {
         Triangle triangle = new Triangle(3, 4, 5);
         assertEquals(TriangleKind.SCALENE, triangle.getKind());
     }
 
+    @Ignore
     @Test
     public void scaleneTrianglesHaveNoEqualSidesAtLargerScaleEither() throws Exception {
         Triangle triangle = new Triangle(10, 11, 12);
         assertEquals(TriangleKind.SCALENE, triangle.getKind());
     }
 
+    @Ignore
     @Test
     public void scaleneTrianglesHaveNoEqualSidesInDescendingOrderEither() throws Exception {
         Triangle triangle = new Triangle(5, 4, 2);
         assertEquals(TriangleKind.SCALENE, triangle.getKind());
     }
 
+    @Ignore
     @Test
     public void verySmallTrianglesAreLegal() throws Exception {
         Triangle triangle = new Triangle(0.4, 0.6, 0.3);
         assertEquals(TriangleKind.SCALENE, triangle.getKind());
     }
 
+    @Ignore
     @Test(expected = TriangleException.class)
     public void trianglesWithNoSizeAreIllegal() throws Exception {
         new Triangle(0, 0, 0);
     }
 
+    @Ignore
     @Test(expected = TriangleException.class)
     public void trianglesWithNegativeSidesAreIllegal() throws Exception {
         new Triangle(3, 4, -5);
     }
 
+    @Ignore
     @Test(expected = TriangleException.class)
     public void trianglesViolatingTriangleInequalityAreIllegal() throws Exception {
         new Triangle(1, 1, 3);
     }
 
+    @Ignore
     @Test(expected = TriangleException.class)
     public void trianglesViolatingTriangleInequalityAreIllegal2() throws Exception {
         new Triangle(2, 4, 2);
     }
 
+    @Ignore
     @Test(expected = TriangleException.class)
     public void trianglesViolatingTriangleInequalityAreIllegal3() throws Exception {
         new Triangle(7, 3, 2);

exercises/trinary/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/trinary/src/test/java/TrinaryTest.java

 import static org.junit.Assert.assertEquals;
 
 import org.junit.Test;
+import org.junit.Ignore;
 
 public class TrinaryTest {
+
     @Test
     public void testNonTrinaryCharacterIsZero() {
         assertEquals(0, Trinary.toDecimal("-"));
     }
 
+    @Ignore
     @Test
     public void testNonTrinaryNumberIsZero() {
         assertEquals(0, Trinary.toDecimal("3"));
     }
 
+    @Ignore
     @Test
     public void testTrinaryWithNonTrinaryIsZero() {
         assertEquals(0, Trinary.toDecimal("102-12"));
     }
 
+    @Ignore
     @Test
     public void testTrinary() {
         assertEquals(302, Trinary.toDecimal("102012"));

exercises/word-count/build.gradle

 dependencies {
   testCompile "junit:junit:4.10"
 }
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

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

 import org.junit.Test;
+import org.junit.Ignore;
 
 import java.lang.Integer;
 import java.lang.String;
 
     private final WordCount wordCount = new WordCount();
 
+
     @Test
     public void countOneWord() {
         Map<String, Integer> actualWordCount = new HashMap<String, Integer>();
         );
     }
 
+    @Ignore
     @Test
     public void countOneOfEach() {
         Map<String, Integer> actualWordCount = new HashMap<String, Integer>();
         );
     }
 
+    @Ignore
     @Test
     public void countMultipleOccurences() {
         Map<String, Integer> actualWordCount = new HashMap<String, Integer>();
         );
     }
 
+    @Ignore
     @Test
     public void ignorePunctuation() {
         Map<String, Integer> actualWordCount = new HashMap<String, Integer>();
 
     }
 
+    @Ignore
     @Test
     public void includeNumbers() {
         Map<String, Integer> actualWordCount = new HashMap<String, Integer>();
         );
     }
 
+    @Ignore
     @Test
     public void normalizeCase() {
         Map<String, Integer> actualWordCount = new HashMap<String, Integer>();

scripts/increase-test-logging.sh

+#!/usr/bin/env bash
+
+LOGGING_CHUNK_FILE=/tmp/test-logging.gradle
+
+cat <<-EOF > $LOGGING_CHUNK_FILE
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}
+EOF
+
+for file in `find . -name "build.gradle"`; do
+  tempfile="/tmp/increase-test-logging.tmp"
+
+  echo -e "\n\n\n*** $file ******************************"
+  cat $file $LOGGING_CHUNK_FILE > "$tempfile"
+  mv "$tempfile" "$file"
+done
+

scripts/insert-ignores.sh

+#!/usr/bin/env bash
+
+for file in `find . -name "*Test.java"`; do
+  tempfile="/tmp/insert-ignores.tmp"
+
+  echo -e "\n\n\n*** $file ******************************"
+  cat $file | \
+  sed 's/import org.junit.Test;/import org.junit.Test;\
+import org.junit.Ignore;/' | \
+  sed 's/@Test/@Ignore\
+    @Test/' | \
+  sed '1,/@Ignore/s/.*@Ignore//' > "$tempfile" \
+  && mv "$tempfile" "$file"
+done
+