Merge pull request #139 from jtigger/ignore-all-but-first-test

Ignore all but first test in hello-world

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

     project["compileStarterSourceJava"].doFirst { compileTask ->
       println "  (source = " + compileTask.source.asPath + ")"
     }
+
+    // In lieu of being able to disable @Ignore in JUnit tests, we filter
+    // those annotations, placing the edited tests in the path named here.
+    test {
+      java.srcDirs = ["build/gen/test/java"]
+    }
+    project["compileTestJava"].doFirst { compileTask ->
+      println "  (source = " + compileTask.source.asPath + ")"
+    }
   }
+
+  task copyTestsFilteringIgnores(type: Copy) {
+    from "src/test/java"
+    into "build/gen/test/java"
+    filter { line ->
+      line.contains("@Ignore") ? "" : line
+    }
+  }
+
+  test.dependsOn(copyTestsFilteringIgnores)
 }

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
   public void startsWithNoStudents() {
     assertThat(school.db()).isEmpty();
   }
 
+  @Ignore
   @Test
   public void addsStudents() {
     school.add("Aimee", 2);
     assertThat(school.db().get(2)).contains("Aimee");
   }
 
+  @Ignore
   @Test
   public void addsMoreStudentsInSameGrade() {
     final int grade = 2;
     assertThat(school.db().get(grade)).hasSize(3).contains("James", "Blair", "Paul");
   }
 
+  @Ignore
   @Test
   public void addsStudentsInMultipleGrades() {
     school.add("Chelsea", 3);
     assertThat(school.db().get(7)).hasSize(1).contains("Logan");
   }
 
+  @Ignore
   @Test
   public void getsStudentsInAGrade() {
     school.add("Franklin", 5);
     assertThat(school.grade(5)).hasSize(2).contains("Franklin", "Bradley");
   }
 
+  @Ignore
   @Test
   public void getsStudentsInEmptyGrade() {
     assertThat(school.grade(1)).isEmpty();
   }
 
+  @Ignore
   @Test
   public void sortsSchool() {
     school.add("Jennifer", 4);

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/GETTING_STARTED.md

-# Getting Started
+NOTE: You can also view the HTML version of this file here:
+https://github.com/exercism/xjava/blob/master/exercises/hello-world/GETTING_STARTED.md
 
-These exercises lean on Test-Driven Development (TDD), but they're not an exact match.
+* [Solving "Hello, World!"](#solving-hello-world)
+ * [Reading Gradle output](#reading-gradle-output)
+ * [Fixing the first failing test](#fixing-the-first-failing-test)
+ * [Enabling and fixing the second test](#enabling-and-fixing-the-second-test)
+ * [Enabling the last test](#enabling-the-last-test)
+ * [Refactoring](#refactoring)
+* [Submitting your first iteration](#submitting-your-first-iteration)
+* [Next Steps](#next-steps)
+ * [Review (and comment on) others' submissions to this exercise](#review-and-comment-on-others-submissions-to-this-exercise)
+ * [Extend an exercise](#extend-an-exercise)
 
-The following steps assume that you are in the base directory of the exercise.
+----
 
-You must have `gradle` installed.
+# Solving "Hello, World!"
 
-## Step 1
+Welcome to the first exercise on the Java track!
 
-Run the test suite. It's written using the JUnit framework, and can be run with gradle:
+This is a step-by-step guide to solving this exercise.
 
-```sh
-$ gradle test
-```
+Each exercise comes with a set of tests.  The first pass through the
+exercise is about getting all of the tests to pass, one at a time.
 
-This will fail, complaining that there is no method called `hello` for the `HelloWorld` class.
+If you have not installed the Java Development Kit and Gradle, you must do
+so now.  For help with this, see: http://exercism.io/languages/java/installing
 
-To fix the error, open `src/main/java/HelloWorld.java` and add a `hello` method that returns a `String`.
-The method can return an empty string `""` for now:
+----
 
-```java
-public class HelloWorld {
-    public static String hello() {
-        return "";
-    }
-}
-```
+This guide picks-up where [Running the Tests (in Java)](http://exercism.io/languages/java/tests)
+left off.  If you haven't reviewed those instructions, do so now.
 
-## Step 2
+The following instructions work equally well on Windows, Mac OS X and Linux.
 
-Run the tests again. It will give you a new error, since now the method exists, but the tests expect the
-method to accept one argument as input, a name.
+## Reading Gradle output
 
-The errors will look something like:
+Use Gradle to run the tests:
 
 ```
 $ gradle test
+```
+
+This command does a lot and displays a bunch of stuff.  Let's break it down...
+
+```
 :compileJava
 :processResources UP-TO-DATE
 :classes
+```
+
+Each line that begins with a colon (like `:compileJava`) is Gradle telling
+us that it's starting that task.  The first three tasks are about compiling
+the source code of our *solution*. We've done you a favor and included just
+enough code for the solution that it compiles.
+
+When a task is successful, it generally does not output anything.  This is
+why `:compileJava` and `:classes` do not produce any additional output.
+`:processResources` reports that it had nothing to do.
+
+So far, so good...
+
+The next three tasks are about compiling source code of the *tests*.
+
+```
 :compileTestJava
-/exercism/exercises/java/hello-world/src/test/java/HelloWorldTest.java:9: error: method hello in class HelloWorld cannot be applied to given types;
-        assertEquals("Hello, World!", HelloWorld.hello(""));
-                                                ^
-  required: no arguments
-  found: String
-  reason: actual and formal argument lists differ in length
+:processTestResources UP-TO-DATE
+:testClasses
+```
 
-  ...
+... with both sets of source code successfully compiled, Gradle turns to
+running the task you asked it to: executing the tests against the solution.
 
-4 errors
-:compileTestJava FAILED
+```
+:test
+
+HelloWorldTest > helloNoName FAILED
+    java.lang.AssertionError: expected:<Hello, World!> but was:<null>
+        at org.junit.Assert.fail(Assert.java:93)
+        at org.junit.Assert.failNotEquals(Assert.java:647)
+        at org.junit.Assert.assertEquals(Assert.java:128)
+        at org.junit.Assert.assertEquals(Assert.java:147)
+        at HelloWorldTest.helloNoName(HelloWorldTest.java:10)
+
+HelloWorldTest > helloSampleName SKIPPED
+
+HelloWorldTest > helloAnotherSampleName SKIPPED
+
+3 tests completed, 1 failed, 2 skipped
+:test FAILED
 
 FAILURE: Build failed with an exception.
 
 * What went wrong:
-Execution failed for task ':compileTestJava'.
-> Compilation failed; see the compiler error output for details.
+Execution failed for task ':test'.
+> There were failing tests. See the report at: file:///Users/jtigger/projects/exercism/xjava/build/exercism/java/hello-world/build/reports/tests/index.html
+
+* Try:
+Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output.
+
+BUILD FAILED
+
+Total time: 6.716 secs
+```
+
+Seeing the word "fail" TEN TIMES might give you the impression you've done
+something horribly wrong.  You haven't.  It's a whole lot of noise over
+a single test not passing.
+
+Let's focus in on the important bits:
+
+```
+HelloWorldTest > helloNoName FAILED
+    java.lang.AssertionError: expected:<Hello, World!> but was:<null>
+```
+
+...is read: "Within the test class named `HelloWorldTest`, the test method
+`helloNoName` did not pass because the solution did not satisfy an
+assertion.  Apparently, we expected to see the string 'Hello, World!' but
+the value `null` was returned instead.
+
+The last line of the stack trace tells us exactly where this unsatisfied
+assertion lives:
+
 ```
+        at HelloWorldTest.helloNoName(HelloWorldTest.java:10)
+```
+
+Looks like the crime was discovered on line 10 in the test file.
+
+Knowing these two facts,
+
+1. the return value was not what was expected, and
+2. the failure was on line 10 of the test,
+ 
+we can turn this failure into success.
 
-### Fixing the Error
 
-To fix it, open `src/main/java/HelloWorld.java` and add a `name` to the method the signature:
+
+## Fixing the first failing test
+
+In your favorite text editor, open `src/test/java/HelloWorldTest.java`
+and go to line 10.
 
 ```java
-public class HelloWorld {
-    public static String hello(String name) {
-        return "";
-    }
-}
+assertEquals("Hello, World!", HelloWorld.hello(""));
 ```
 
-Now the `hello` method accepts a `name` as an input.
+The test is expecting that `hello()`, when given an empty string (`""`),
+returns "Hello, World!".  Instead, `hello()` is returning `null`.
+Let's fix that.
 
-### Understanding Test Failures
+Open `src/main/java/HelloWorld.java`.
 
-Test failures will either be compilation errors or test failures. So far, we've been dealing with compilation
-errors. Once our test and main code successful compile, `gradle` will run the actual test suite.
+```java
+public class HelloWorld {
+  public static String hello(String name) {
+    return null;
+  }
+}
+```
 
-## Step 3
+Let's change that to return the expected string:
 
-Run the tests again. You'll notice that the gradle output passes the `:compileTestJava` phase and fails
-at the `:test` phase.
+```java
+public class HelloWorld {
+  public static String hello(String name) {
+    return "Hello, World!";
+  }
+}
+```
 
-The errors will look something like:
+Save the file and run the tests again:
 
 ```
 $ gradle test
 :testClasses
 :test
 
-HelloWorldTest > helloNoName FAILED
-    org.junit.ComparisonFailure at HelloWorldTest.java:9
+HelloWorldTest > helloAnotherSampleName SKIPPED
+
+HelloWorldTest > helloNoName PASSED
+
+HelloWorldTest > helloSampleName SKIPPED
+
+BUILD SUCCESSFUL
+
+Total time: 4.523 secs
+```
+
+"BUILD SUCCESSFUL"!  Woohoo! :)  You can see that `helloNoName()` test is
+now passing.
+
+With one win under our belt, we can turn our focus to some other messages
+that we've been ignoring: the lines ending in "`SKIPPED`".
+
+Each test suite contains a series of tests, all of which have been marked
+to be skipped/ignored except the first one.  We did this to help you focus
+on getting one test running at a time.
 
+Let's tackle the next test...
+
+
+
+## Enabling and fixing the second test
+
+Right now, that second test is being skipped/ignored.  Let's enable it.
+
+(Re)open `src/test/java/HelloWorldTest.java` and find the second test:
+
+```java
 ...
+@Test
+@Ignore
+public void helloSampleName() {
+  assertEquals("Hello, Alice!", HelloWorld.hello("Alice"));
+}
+...
+```
 
-3 tests completed, 3 failed
-:test FAILED
+When the JUnit test runner sees that `@Ignore` annotation on the test
+method, it knows to skip over that test.  Remove that line:
+
+```java
+...
+@Test
+public void helloSampleName() {
+  assertEquals("Hello, Alice!", HelloWorld.hello("Alice"));
+}
+...
+```
+
+Now, when you run the tests, both tests run:
+
+```sh
+$ gradle test
+...
+:test
+
+HelloWorldTest > helloNoName PASSED
+
+HelloWorldTest > helloSampleName FAILED
+    org.junit.ComparisonFailure: expected:<Hello, [Alice]!> but was:<Hello, [World]!>
+        at org.junit.Assert.assertEquals(Assert.java:125)
+        at org.junit.Assert.assertEquals(Assert.java:147)
+        at HelloWorldTest.helloSampleName(HelloWorldTest.java:16)
+
+HelloWorldTest > helloAnotherSampleName SKIPPED
+
+3 tests completed, 1 failed, 1 skipped
+...
 ```
 
-These are actual test failures. It means that both our main and test java code is running but the test is
-expecting one outcome, but getting another.
+The first test, `helloNoName()` continues to pass.  We see that
+`helloSampleName` -- the test we just un-`@Ignore`'d -- is now running and
+failing.  Yay, failing test!  In fact, the "failure" message is just
+describing the difference between what the program does now and what it
+should do for us to call it "done."
 
-Open `src/test/java/HelloWorldTest.java` and go to line 9.
+Right now, we've hardcoded the greeting.  Enabling this second test has
+unleashed a new expectation: that our program incorporate a name given
+into that greeting.  When given the name "`Alice`", that's who should be
+greeted instead of "`World`".
+
+(Re)open `src/main/java/HelloWorld.java`.
 
 ```java
-assertEquals("Hello, World!", HelloWorld.hello(""));
+public class HelloWorld {
+  public static String hello(String name) {
+    return "Hello, World!";
+  }
+}
+```
+
+While `hello()` does accept a reference to a string named `name`, it is not
+using it in the output.  Let's change that:
+
+
+```java
+public class HelloWorld {
+  public static String hello(String name) {
+    return "Hello, " + name + "!";
+  }
+}
+```
+
+... and rerun the tests ...
+
+```
+$ gradle test
+:test
+
+HelloWorldTest > helloAnotherSampleName SKIPPED
+
+HelloWorldTest > helloNoName FAILED
+    org.junit.ComparisonFailure: expected:<Hello, [World]!> but was:<Hello, []!>
+        at org.junit.Assert.assertEquals(Assert.java:125)
+        at org.junit.Assert.assertEquals(Assert.java:147)
+        at HelloWorldTest.helloNoName(HelloWorldTest.java:10)
+
+HelloWorldTest > helloSampleName PASSED
+
+3 tests completed, 1 failed, 1 skipped
 ```
 
-The test is expecting that `hello` returns "Hello, World!", when given an empty string (`""`) as input.
-The easiest way to make the test pass is to return `"Hello, World!"` instead of `"".
+Wait... didn't we just fix the test?  Why is it failing?  Take a closer look...
 
+In fact, `helloSampleName()` *is* passing.  It's just that at the same time,
+we just inadvertently broke that first test: `helloNoName()`.
+
+This is one tiny example of the benefit of maintaining a test suite: if we
+use them to drive out our code, the second we break the program the tests
+say so.  Since we saw them passing just *before* our latest change,
+whatever we *just* did most likely cause that regression.
+
+Our latest change was making the greeting dependent on the name given. Our
+first test expects that if either a blank string or null are given as the
+name, then "`World`" should be substituted in.  Let's implement that.
+
+`src/main/java/HelloWorld.java`:
 ```java
 public class HelloWorld {
-    public static String hello(String name) {
-        return "Hello, World!";
+  public static String hello(String name) {
+    if(name == null || "".equals(name)) {
+      name = "World";
     }
+    return "Hello, " + name + "!";
+  }
 }
 ```
 
-## Wash, Rinse, Repeat
+... and re-run the tests ...
 
-Run the tests again.
+```
+$ gradle test
+...
+:test
 
-If it fails you're going to need to read the error message carefully to figure out what went wrong, fix the problem
-in the main code, and then try again until all the tests pass.
+HelloWorldTest > helloNoName PASSED
+
+HelloWorldTest > helloSampleName PASSED
+
+HelloWorldTest > helloAnotherSampleName SKIPPED
+
+BUILD SUCCESSFUL
+
+Total time: 4.804 secs
+```
+
+Excellent!  We're now (at least) two-thirds the way done.  Just one more
+test to go...
+
+
+
+## Enabling the last test
+
+(Re)open `src/test/java/HelloWorldTest.java` and find the last test:
+
+```java
+...
+@Test
+@Ignore
+public void helloAnotherSampleName() {
+    assertEquals("Hello, Bob!", HelloWorld.hello("Bob"));
+}
+...
+```
+
+... and remove it's `@Ignore` to enable it ...
+
+```java
+...
+@Test
+public void helloAnotherSampleName() {
+    assertEquals("Hello, Bob!", HelloWorld.hello("Bob"));
+}
+...
+```
+
+... and re-run the tests ...
 
 ```
 $ gradle test
-:compileJava
+:compileJava UP-TO-DATE
 :processResources UP-TO-DATE
-:classes
+:classes UP-TO-DATE
 :compileTestJava
 :processTestResources UP-TO-DATE
 :testClasses
 :test
 
+HelloWorldTest > helloNoName PASSED
+
+HelloWorldTest > helloSampleName PASSED
+
+HelloWorldTest > helloAnotherSampleName PASSED
+
 BUILD SUCCESSFUL
+
+Total time: 6.953 secs
 ```
 
-## Submit
+Oh, hello!  Turns out, the solution we put into place didn't just apply for
+"`Alice`" but "`Bob`" equally well.  In this case, the test succeeded with
+no additional code on our part.
+
+
+
+## Refactoring
+
+Now that you've got all the tests passing, you might consider whether
+the code is in the most readable/maintainable/efficient shape.  What makes
+for "good" design of software is a big topic.  The pursuit of it underlies
+much of what makes up the more valuable conversations on Exercism.
 
-When everything is passing, you can submit your code with the following command:
+For now, let's just take a quick review of our solution and see if there's
+any part of it we'd like to refactor.  Refactoring is changing the the way
+a bit of code reads without changing what it does.
+
+Right now, the details of detecting whether the caller of `hello()` has
+given a name or not (i.e. `name` is either `null` or an empty string) is
+sitting right next to the core responsibility of the method: to produce a
+personalized greeting.
+
+```java
+public class HelloWorld {
+  public static String hello(String name) {
+    if(name == null || "".equals(name)) {
+      name = "World";
+    }
+    return "Hello, " + name + "!";
+  }
+}
+```
+
+How would things read if we extracted those details into a separate method
+and at the same time, replaced the `if` with a ternary expression?
+
+```java
+public class HelloWorld {
+
+  public static String hello(String name) {
+    String whom = isBlank(name) ? "World" : name;
+    return "Hello, " + whom + "!";
+  }
+
+  private static boolean isBlank(String string) {
+    return string == null || "".equals(string);
+  }
+}
+```
+
+By extracting that logic into the `isBlank()` method, we've added a little
+abstraction to our program -- it's not as literal as it was before.  Yet,
+it allows us to defer *needing* to understand *how* "blankness" is
+detected.  If we can assume that `isBlank()` just works, we don't have to
+downshift in our head to those details.  Instead, we can remain at the same
+level of thinking: to whom are we greeting?
+
+The ternary operator allowed us to express that choice in a more compact
+form.  Less to read without losing the intent.
+
+Finally, we introduced another variable: `whom`.  Doing so gives a name to
+the output of the ternary expression.  We certainly could have continued
+to reuse `name`, but by introducing a second `String` to hold the
+calculated value this keeps crisp the two ideas: `name` is what's given
+and `whom` is what's been determined.
+
+We made a bunch of changes, let's make sure we didn't break the program!
+
+```
+$ gradle test
+...
+HelloWorldTest > helloNoName PASSED
+
+HelloWorldTest > helloSampleName PASSED
+
+HelloWorldTest > helloAnotherSampleName PASSED
+...
+```
+
+This illustrates another benefit of writing tests: you can make significant
+changes to the structure of the program and very quickly restore your
+confidence that the program still works.  These tests are a far cry from a
+"proof" of correctness, but well-written tests do a much better job of
+(very quickly) giving us evidence that it is.  Without them, we manually
+run the program with different inputs and/or inspecting the code
+line-by-line -- time-consuming and error prone.
+
+
+
+# Submitting your first iteration
+
+With a working solution that we've reviewed, we're ready to submit it to
+exercism.io.
 
 ```
 $ exercism submit src/main/java/HelloWorld.java
 
 
 
+# Next Steps
+
+From here, there are a number of paths you can take.
+
+
+## Move on to the next exercise
+
+There are many more exercises you can practice with.  Grab the next one!
+
+```
+$ exercism fetch java
+```
+
+
+## Review (and comment on) others' submissions to this exercise
+
+The heart of Exercism are the conversations about coding
+practices.  It's definitely fun to practice, but engaging with others
+both in their attempts and your own is how you get feedback.  That feedback
+can help point out what you're doing well and where you might need to
+improve.
+
+Some submissions will be nearly identical to yours; others will be
+completely different.  Seeing both kinds can be instructive and interesting.
+
+Note that you can only view submissions of others for exercises you have
+completed yourself.  This enriches the experience of reading others' code
+because you'll have your own experience of trying to solve the problem.
+
+Here's an up-to-date list of submissions on the Java track:
+
+http://exercism.io/tracks/java/exercises
+
+
+
+## Submit another iteration
+
+You are also encouraged to consider additional "requirements" on a given
+exercise.
+
+For example, you could add a test or two that requires that the greeting
+use the capitalized form on the person's name, regardless of the case they
+used.
+
+In that situation, you'd write a test to set-up that new expectation and
+then implement that in the code (the same process we just went through
+together, above).
+
+
+
+## Contribute to Exercism
+
+The entire of Exercism is Open Source and is the labor of love for over
+100 maintainers and many more contributors.
+
+A starting point to jumping in can be found here:
+
+https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md
+
+
+----
+
+Regardless of what you decide to do next, we sincerely hope you learn
+and enjoy being part of this community.  If at any time you need assistance
+do not hesitate to ask for help:
+
+http://exercism.io/languages/java/help
+
+Cheers!

exercises/hello-world/build.gradle

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

exercises/hello-world/src/main/java/HelloWorld.java

 public class HelloWorld {
+	public static String hello(String name) {
+      return null;
+	}
 }

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(""));
     }
 
     @Test
+    @Ignore
     public void helloSampleName() {
         assertEquals("Hello, Alice!", HelloWorld.hello("Alice"));
     }
 
     @Test
+    @Ignore
     public void helloAnotherSampleName() {
         assertEquals("Hello, Bob!", HelloWorld.hello("Bob"));
     }

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
+