Standardize order of test annotations

POLICIES.md

 
 ### Ignore noninitial tests
 
-> All but the first test in an exercise test suite should be annotated `@Ignore("Remove to run test")` (single test) or `@Ignore("Remove to run tests")` (parametrized test).
+> All but the first test in an exercise test suite should add `@Ignore("Remove to run test")` (single test) or `@Ignore("Remove to run tests")` (parametrized test) on the line before the corresponding `@Test` annotation.
 
 References: [[1](https://github.com/exercism/java/issues/101#issuecomment-249349204)]
 

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

         assertEquals(expected, actual);
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void insertsLess() {
         BST<Integer> bst = new BST();
         final int expectedRoot = 4;
         assertEquals(expectedRoot, actualRoot);
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void insertsSame() {
         BST<Integer> bst = new BST();
         final int expectedRoot = 4;
         assertEquals(expectedRoot, actualRoot);
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void insertsRight() {
         BST<Integer> bst = new BST();
         final int expectedRoot = 4;
         assertEquals(expectedRoot, actualRoot);
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void createsComplexTree() {
         BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
         assertEquals(expected, actual);
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void sortsSingleElement() {
         BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
         assertEquals(expected, actual);
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void sortsCollectionOfTwoIfSecondInsertedIsSmallerThanFirst() {
         BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
         assertEquals(expected, actual);
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void sortsCollectionOfTwoIfSecondInsertedIsBiggerThanFirst() {
         BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
         assertEquals(expected, actual);
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void iteratesOverComplexTree() {
         BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(

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

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

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

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

exercises/poker/src/test/java/PokerTest.java

         assertEquals(Arrays.asList(hand),new Poker(Arrays.asList(hand)).getBestHands());
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void nothingVsOnePair() {
         final String nothing = "4S 5H 6S 8D JH";
         final String pairOf4 = "2S 4H 6S 4D JH";
         assertEquals(Arrays.asList(pairOf4),new Poker(Arrays.asList(nothing, pairOf4)).getBestHands());
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void twoPairs() {
         final String pairOf2 = "4S 2H 6S 2D JH";
         final String pairOf4 = "2S 4H 6S 4D JH";
         assertEquals(Arrays.asList(pairOf4), new Poker(Arrays.asList(pairOf2,pairOf4)).getBestHands());
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void onePairVsDoublePair() {
         final String pairOf8 = "2S 8H 6S 8D JH";
         final String doublePair = "4S 5H 4S 8D 5H";
         assertEquals(Arrays.asList(doublePair),  new Poker(Arrays.asList(pairOf8, doublePair)).getBestHands());
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void twoDoublePairs() {
         final String doublePair2And8 = "2S 8H 2S 8D JH";
         final String doublePair4And5 = "4S 5H 4S 8D 5H";
         assertEquals(Arrays.asList(doublePair2And8), new Poker(Arrays.asList(doublePair2And8, doublePair4And5)).getBestHands());
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void doublePairVsThree() {
         final String doublePair2And8 = "2S 8H 2S 8D JH";
         final String threeOf4 = "4S 5H 4S 8D 4H";
         assertEquals(Arrays.asList(threeOf4 ), new Poker(Arrays.asList(doublePair2And8, threeOf4)).getBestHands());
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void twoThrees() {
         final String threeOf2 = "2S 2H 2S 8D JH";
         final String threeOf1 = "4S AH AS 8D AH";
         assertEquals(Arrays.asList(threeOf1), new Poker(Arrays.asList(threeOf2, threeOf1)).getBestHands());
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void threeVsStraight() {
         final String threeOf4 = "4S 5H 4S 8D 4H";
         final String straight = "3S 4H 2S 6D 5H";
         assertEquals(Arrays.asList(straight), new Poker(Arrays.asList(threeOf4, straight)).getBestHands());
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void twoStraights() {
         final String straightTo8 = "4S 6H 7S 8D 5H";
         final String straightTo9 = "5S 7H 8S 9D 6H";
         assertEquals(Arrays.asList(straightTo1), new Poker(Arrays.asList(straightTo1, straightTo5)).getBestHands());
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void straightVsFlush() {
         final String straightTo8 = "4S 6H 7S 8D 5H";
         final String flushTo7 = "2S 4S 5S 6S 7S";
         assertEquals(Arrays.asList(flushTo7 ), new Poker(Arrays.asList(straightTo8, flushTo7)).getBestHands());
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void twoFlushes() {
         final String flushTo8 = "3H 6H 7H 8H 5H";
         final String flushTo7 = "2S 4S 5S 6S 7S";
         assertEquals(Arrays.asList(flushTo8), new Poker(Arrays.asList(flushTo8, flushTo7)).getBestHands());
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void flushVsFull() {
         final String flushTo8 = "3H 6H 7H 8H 5H";
         final String full = "4S 5H 4S 5D 4H";
         assertEquals(Arrays.asList(full ), new Poker(Arrays.asList(full, flushTo8)).getBestHands());
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void twoFulls() {
         final String fullOf4By9 = "4H 4S 4D 9S 9D";
         final String fullOf5By8 = "5H 5S 5D 8S 8D";
         assertEquals(Arrays.asList(fullOf5By8 ), new Poker(Arrays.asList(fullOf4By9, fullOf5By8)).getBestHands());
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void fullVsSquare() {
         final String full = "4S 5H 4S 5D 4H";
         final String squareOf3 = "3S 3H 2S 3D 3H";
         assertEquals(Arrays.asList(squareOf3 ), new Poker(Arrays.asList(full, squareOf3)).getBestHands());
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void twoSquares() {
         final String squareOf2 = "2S 2H 2S 8D 2H";
         final String squareOf5 = "4S 5H 5S 5D 5H";
         assertEquals(Arrays.asList(squareOf5), new Poker(Arrays.asList(squareOf2, squareOf5)).getBestHands());
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void squareVsStraightFlush() {
         final String squareOf5 = "4S 5H 5S 5D 5H";
         final String straightFlushTo9 = "5S 7S 8S 9S 6S";
         assertEquals(Arrays.asList(straightFlushTo9 ), new Poker(Arrays.asList(squareOf5, straightFlushTo9)).getBestHands());
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void twoStraightFlushes() {
         final String straightFlushTo8 = "4H 6H 7H 8H 5H";
         final String straightFlushTo9 = "5S 7S 8S 9S 6S";
         assertEquals(Arrays.asList(straightFlushTo9 ), new Poker(Arrays.asList(straightFlushTo8, straightFlushTo9)).getBestHands());
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void threeHandWithTie() {
         final String spadeStraightTo9 = "9S 8S 7S 6S 5S";
         final String diamondStraightTo9 = "9D 8D 7D 6D 5D";
         assertEquals(Arrays.asList(spadeStraightTo9, diamondStraightTo9), new Poker(Arrays.asList(spadeStraightTo9, diamondStraightTo9, threeOf4)).getBestHands());
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void straightTo5AgainstAPairOfJacks() {
         final String straightTo5 = "2S 4D 5C 3S AS";
         final String twoJacks = "JD 8D 7D JC 5D";

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

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

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

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

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

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

exercises/transpose/src/test/java/TransposeTest.java

         assertEquals(expected, transpose.transpose(input));
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void twoCharsInARow() {
         String input = "A1";
 
         assertEquals(expected, transpose.transpose(input));
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void twoCharsInAColumn() {
         String input = "A\n" +
                        "1";
         assertEquals(expected, transpose.transpose(input));
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void simpleMatrix() {
         String input = "ABC\n" +
                        "123";
         assertEquals(expected, transpose.transpose(input));
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void singleLine() {
         String input = "Single line.";
 
         assertEquals(expected, transpose.transpose(input));
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void firstLineLongerThanSecond() {
         String input = "The fourth line.\n" +
                        "The fifth line.";
         assertEquals(expected, transpose.transpose(input));
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void secondLineLongerThanFirst() {
         String input = "The first line.\n" +
                        "The second line.";
         assertEquals(expected, transpose.transpose(input));
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void square() {
         String input = "HEART\n" +
                        "EMBER\n" +
         assertEquals(expected, transpose.transpose(input));
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void rectangle() {
         String input = "FRACTURE\n" +
                        "OUTLINED\n" +
         assertEquals(expected, transpose.transpose(input));
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void triangle() {
         String input = "T\n" +
                        "EE\n" +
         assertEquals(expected, transpose.transpose(input));
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void manyLines() {
         String input = "Chor. Two households, both alike in dignity,\n" +
                        "In fair Verona, where we lay our scene,\n" +
 
         assertEquals(expected, transpose.transpose(input));
     }
-}
+}

exercises/two-fer/src/test/java/TwoferTest.java

         assertEquals(expected, twofer.twofer(input));
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void aNameGiven() {
         String input = "Alice";
         String expected = "One for Alice, one for me.";
         assertEquals(expected, twofer.twofer(input));
     }
 
-    @Test
     @Ignore("Remove to run test")
+    @Test
     public void anotherNameGiven() {
         String input = "Bob";
         String expected = "One for Bob, one for me.";
 
         assertEquals(expected, twofer.twofer(input));
     }
-}
+}