Merge remote-tracking branch 'upstream/master'

exercises/acronym/src/example/java/Acronym.java

 import java.util.regex.Pattern;
 
 public class Acronym {
-    public static String generate(String phrase){
+    private final String acronym;
+
+    public Acronym(String phrase) {
+        acronym = generateAcronym(phrase);
+    }
+
+    public String get() {
+        return acronym;
+    }
+
+    private String generateAcronym(String phrase){
         final Pattern BREAK_WORDS = Pattern.compile("[A-Z]+[a-z]*|[a-z]+");
         final Matcher matcher = BREAK_WORDS.matcher(phrase);
         final StringBuilder b = new StringBuilder();

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

 
 public class AcronymTest {
 
-
     @Test
     public void fromTitleCasedPhrases() {
         final String phrase = "Portable Network Graphics";
         final String expected = "PNG";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore
     public void fromOtherTitleCasedPhrases() {
         final String phrase = "Ruby on Rails";
         final String expected = "ROR";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore
     public void fromInconsistentlyCasedPhrases() {
         final String phrase = "HyperText Markup Language";
         final String expected = "HTML";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore
     public void fromPhrasesWithPunctuation() {
         final String phrase = "First In, First Out";
         final String expected = "FIFO";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore
     public void fromOtherPhrasesWithPunctuation() {
         final String phrase = "PHP: Hypertext Preprocessor";
         final String expected = "PHP";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore
     public void fromPhrasesWithNonAcronymAllCapsWord() {
         final String phrase = "GNU Image Manipulation Program";
         final String expected = "GIMP";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore
     public void fromPhrasesWithPunctuationAndSentenceCasing() {
         final String phrase = "Complementary metal-oxide semiconductor";
         final String expected = "CMOS";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore
     public void fromPhraseWithSingleLetterWord() {
         final String phrase = "Cat in a Hat";
         final String expected = "CIAH";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
 }

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

 import org.junit.Ignore;
+import org.junit.Before;
 import org.junit.Test;
 
 import java.util.List;
 import static org.junit.Assert.assertThat;
 
 public final class DiamondPrinterTest {
-
+    private DiamondPrinter diamondPrinter;
+    
+    @Before
+    public void setUp() {
+        diamondPrinter = new DiamondPrinter();
+    }
+        
     @Test
     public void testOneByOneDiamond() {
-        List<String> output = new DiamondPrinter().printToList('A');
+        List<String> output = diamondPrinter.printToList('A');
         assertThat(output, is(singletonList("A")));
     }
 
     @Ignore
     @Test
     public void testTwoByTwoDiamond() {
-        List<String> output = new DiamondPrinter().printToList('B');
+        List<String> output = diamondPrinter.printToList('B');
         assertThat(output, is(asList(" A ",
                                      "B B",
                                      " A ")));
     @Ignore
     @Test
     public void testThreeByThreeDiamond() {
-        List<String> output = new DiamondPrinter().printToList('C');
+        List<String> output = diamondPrinter.printToList('C');
         assertThat(output, is(asList("  A  ",
                                      " B B ",
                                      "C   C",
     @Ignore
     @Test
     public void testFiveByFiveDiamond() {
-        List<String> output = new DiamondPrinter().printToList('E');
+        List<String> output = diamondPrinter.printToList('E');
         assertThat(output, is(asList("    A    ",
                                      "   B B   ",
                                      "  C   C  ",
     @Ignore
     @Test
     public void testFullDiamond() {
-        List<String> output = new DiamondPrinter().printToList('Z');
+        List<String> output = diamondPrinter.printToList('Z');
         assertThat(output, is(asList("                         A                         ",
                                      "                        B B                        ",
                                      "                       C   C                       ",

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

+import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
 
 public class SchoolTest {
-  private final School school = new School();
+  private School school;
+
+  @Before
+  public void setUp() {
+    school = new School();
+  }
 
   @Test
   public void startsWithNoStudents() {
       // Such as UnsupportedOperationException when an unmodifiableMap is used
     }
 
-    assertThat(school.studentsByGradeAlphabetical().get(grade), 
+    assertThat(school.studentsByGradeAlphabetical().get(grade),
       not(hasItem(studentWhichShouldNotBeAdded)));
   }
 }

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

 import org.junit.Ignore;
+import org.junit.Before;
 import org.junit.Test;
 
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
 public class LuhnValidatorTest {
+    private LuhnValidator luhnValidator;
+
+    @Before
+    public void setUp() {
+      luhnValidator = new LuhnValidator();
+    }
 
     @Test
     public void testThatSingleDigitStringIsNotValid() {
-        assertFalse(new LuhnValidator().isValid("1"));
+        assertFalse(luhnValidator.isValid("1"));
     }
 
     @Ignore
     @Test
     public void testThatTheStringConsistingOfASingleZeroIsInvalid() {
-        assertFalse(new LuhnValidator().isValid("0"));
+        assertFalse(luhnValidator.isValid("0"));
     }
 
     @Ignore
     @Test
     public void testThatASimpleValidNumberIsIdentifiedAsValid() {
-        assertTrue(new LuhnValidator().isValid(" 5 9 "));
+        assertTrue(luhnValidator.isValid(" 5 9 "));
     }
 
     @Ignore
     @Test
     public void testThatAValidCanadianSocialInsuranceNumberIsIdentifiedAsValidV1() {
-        assertTrue(new LuhnValidator().isValid("046 454 286"));
+        assertTrue(luhnValidator.isValid("046 454 286"));
     }
 
     @Ignore
     @Test
     public void testThatAValidCanadianSocialInsuranceNumberIsIdentifiedAsValidV2() {
-        assertTrue(new LuhnValidator().isValid("055 444 285"));
+        assertTrue(luhnValidator.isValid("055 444 285"));
     }
 
     @Ignore
     @Test
     public void testThatAnInvalidCanadianSocialInsuranceNumberIsIdentifiedAsInvalid() {
-        assertFalse(new LuhnValidator().isValid("046 454 287"));
+        assertFalse(luhnValidator.isValid("046 454 287"));
     }
 
     @Ignore
     @Test
     public void testThatAnInvalidCreditCardIsIdentifiedAsInvalid() {
-        assertFalse(new LuhnValidator().isValid("8273 1232 7352 0569"));
+        assertFalse(luhnValidator.isValid("8273 1232 7352 0569"));
     }
 
     @Ignore
     @Test
     public void testThatAddingANonDigitCharacterToAValidStringInvalidatesTheString() {
-        assertFalse(new LuhnValidator().isValid("046a 454 286"));
+        assertFalse(luhnValidator.isValid("046a 454 286"));
     }
 
     @Ignore
     @Test
     public void testThatStringContainingPunctuationIsInvalid() {
-        assertFalse(new LuhnValidator().isValid("055-444-285"));
+        assertFalse(luhnValidator.isValid("055-444-285"));
     }
 
     @Ignore
     @Test
     public void testThatStringContainingSymbolsIsInvalid() {
-        assertFalse(new LuhnValidator().isValid("055£ 444$ 285"));
+        assertFalse(luhnValidator.isValid("055£ 444$ 285"));
     }
 
     @Ignore
     @Test
     public void testThatTheStringConsistingOfASpaceAndASingleZeroIsInvalid() {
-        assertFalse(new LuhnValidator().isValid(" 0"));
+        assertFalse(luhnValidator.isValid(" 0"));
     }
 
     @Ignore
     @Test
     public void testThatStringContainingMultipleZerosIsValid() {
-        assertTrue(new LuhnValidator().isValid(" 00000"));
+        assertTrue(luhnValidator.isValid(" 00000"));
     }
 
     @Ignore
     @Test
     public void testThatDoublingNineIsHandledCorrectly() {
-        assertTrue(new LuhnValidator().isValid("091"));
+        assertTrue(luhnValidator.isValid("091"));
     }
 
 }

exercises/raindrops/src/example/java/Raindrops.java → exercises/raindrops/src/example/java/RaindropConverter.java

-public class Raindrops {
+public class RaindropConverter {
 
-    public static String convert(int number) {
+    public String convert(int number) {
         String result = "";
 
         if (number % 3 == 0) {

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

 import static org.junit.Assert.assertEquals;
 
 @RunWith(Parameterized.class)
-public class RaindropsTest {
+public class RaindropConverterTest {
 
     private int inputNumber;
     private String outputFromRaindropConversion;
         });
     }
 
-    public RaindropsTest(int inputNumber, String outputFromRaindropConversion) {
+    public RaindropConverterTest(int inputNumber, String outputFromRaindropConversion) {
         this.inputNumber = inputNumber;
         this.outputFromRaindropConversion = outputFromRaindropConversion;
     }
 
     @Test
     public void test() {
-        assertEquals(outputFromRaindropConversion, Raindrops.convert(inputNumber));
+        assertEquals(outputFromRaindropConversion, new RaindropConverter().convert(inputNumber));
     }
 }

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

 import org.junit.Test;
 import org.junit.Ignore;
+import org.junit.Before;
 
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.core.Is.is;
 public class RobotTest {
 
     private static final String EXPECTED_ROBOT_NAME_PATTERN = "[A-Z]{2}\\d{3}";
-    private final Robot robot = new Robot();
+    private Robot robot;
 
+    @Before
+    public void setUp() {
+      robot = new Robot();
+    }
 
     @Test
     public void hasName() {

exercises/secret-handshake/src/test/java/HandshakeCalculatorTest.java

 import org.junit.Ignore;
+import org.junit.Before;
 import org.junit.Test;
 
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertEquals;
 
 public final class HandshakeCalculatorTest {
-
+    private HandshakeCalculator handshakeCalculator;
+    
+    
+    @Before
+    public void setUp() {
+        handshakeCalculator = new HandshakeCalculator();
+    }
+    
     @Test
     public void testThatInput1YieldsAWink() {
         assertEquals(
                 singletonList(Signal.WINK),
-                new HandshakeCalculator().calculateHandshake(1));
+                handshakeCalculator.calculateHandshake(1));
     }
 
     @Ignore
     public void testThatInput2YieldsADoubleBlink() {
         assertEquals(
                 singletonList(Signal.DOUBLE_BLINK),
-                new HandshakeCalculator().calculateHandshake(2));
+                handshakeCalculator.calculateHandshake(2));
     }
 
     @Ignore
     public void testThatInput4YieldsACloseYourEyes() {
         assertEquals(
                 singletonList(Signal.CLOSE_YOUR_EYES),
-                new HandshakeCalculator().calculateHandshake(4));
+                handshakeCalculator.calculateHandshake(4));
     }
 
     @Ignore
     public void testThatInput8YieldsAJump() {
         assertEquals(
                 singletonList(Signal.JUMP),
-                new HandshakeCalculator().calculateHandshake(8));
+               handshakeCalculator.calculateHandshake(8));
     }
 
     @Ignore
     public void testAnInputThatYieldsTwoActions() {
         assertEquals(
                 asList(Signal.WINK, Signal.DOUBLE_BLINK),
-                new HandshakeCalculator().calculateHandshake(3));
+                handshakeCalculator.calculateHandshake(3));
     }
 
     @Ignore
     public void testAnInputThatYieldsTwoReversedActions() {
         assertEquals(
                 asList(Signal.DOUBLE_BLINK, Signal.WINK),
-                new HandshakeCalculator().calculateHandshake(19));
+               handshakeCalculator.calculateHandshake(19));
     }
 
     @Ignore
     public void testReversingASingleActionYieldsTheSameAction() {
         assertEquals(
                 singletonList(Signal.JUMP),
-                new HandshakeCalculator().calculateHandshake(24));
+                handshakeCalculator.calculateHandshake(24));
     }
 
     @Ignore
     public void testReversingNoActionsYieldsNoActions() {
         assertEquals(
                 emptyList(),
-                new HandshakeCalculator().calculateHandshake(16));
+                handshakeCalculator.calculateHandshake(16));
     }
 
     @Ignore
     public void testInputThatYieldsAllActions() {
         assertEquals(
                 asList(Signal.WINK, Signal.DOUBLE_BLINK, Signal.CLOSE_YOUR_EYES, Signal.JUMP),
-                new HandshakeCalculator().calculateHandshake(15));
+                handshakeCalculator.calculateHandshake(15));
     }
 
     @Ignore
     public void testInputThatYieldsAllActionsReversed() {
         assertEquals(
                 asList(Signal.JUMP, Signal.CLOSE_YOUR_EYES, Signal.DOUBLE_BLINK, Signal.WINK),
-                new HandshakeCalculator().calculateHandshake(31));
+                handshakeCalculator.calculateHandshake(31));
     }
 
     @Ignore
     public void testThatInput0YieldsNoActions() {
         assertEquals(
                 emptyList(),
-                new HandshakeCalculator().calculateHandshake(0));
+                handshakeCalculator.calculateHandshake(0));
     }
 
     @Ignore
     public void testThatInputWithLower5BitsNotSetYieldsNoActions() {
         assertEquals(
                 emptyList(),
-                new HandshakeCalculator().calculateHandshake(32));
+                handshakeCalculator.calculateHandshake(32));
     }
 
 }

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

 import org.junit.Ignore;
 import org.junit.Rule;
 import org.junit.Test;
+import org.junit.Before;
 import org.junit.rules.ExpectedException;
 
 import static org.junit.Assert.assertEquals;
     @Rule
     public ExpectedException expectedException = ExpectedException.none();
 
+    WordProblemSolver solver;
+
+    @Before
+    public void setup() {
+        solver = new WordProblemSolver();
+    }
+
     @Test
     public void testSingleAddition1() {
-        assertEquals(2, new WordProblemSolver().solve("What is 1 plus 1?"));
+        assertEquals(2, solver.solve("What is 1 plus 1?"));
     }
 
     @Ignore
     @Test
     public void testSingleAddition2() {
-        assertEquals(55, new WordProblemSolver().solve("What is 53 plus 2?"));
+        assertEquals(55, solver.solve("What is 53 plus 2?"));
     }
 
     @Ignore
     @Test
     public void testSingleAdditionWithNegativeNumbers() {
-        assertEquals(-11, new WordProblemSolver().solve("What is -1 plus -10?"));
+        assertEquals(-11, solver.solve("What is -1 plus -10?"));
     }
 
     @Ignore
     @Test
     public void testSingleAdditionOfLargeNumbers() {
-        assertEquals(45801, new WordProblemSolver().solve("What is 123 plus 45678?"));
+        assertEquals(45801, solver.solve("What is 123 plus 45678?"));
     }
 
     @Ignore
     @Test
     public void testSingleSubtraction() {
-        assertEquals(16, new WordProblemSolver().solve("What is 4 minus -12?"));
+        assertEquals(16, solver.solve("What is 4 minus -12?"));
     }
 
     @Ignore
     @Test
     public void testSingleMultiplication() {
-        assertEquals(-75, new WordProblemSolver().solve("What is -3 multiplied by 25?"));
+        assertEquals(-75, solver.solve("What is -3 multiplied by 25?"));
     }
 
     @Ignore
     @Test
     public void testSingleDivision() {
-        assertEquals(-11, new WordProblemSolver().solve("What is 33 divided by -3?"));
+        assertEquals(-11, solver.solve("What is 33 divided by -3?"));
     }
 
     @Ignore
     @Test
     public void testMultipleAdditions() {
-        assertEquals(3, new WordProblemSolver().solve("What is 1 plus 1 plus 1?"));
+        assertEquals(3, solver.solve("What is 1 plus 1 plus 1?"));
     }
 
     @Ignore
     @Test
     public void testAdditionThenSubtraction() {
-        assertEquals(8, new WordProblemSolver().solve("What is 1 plus 5 minus -2?"));
+        assertEquals(8, solver.solve("What is 1 plus 5 minus -2?"));
     }
 
     @Ignore
     @Test
     public void testMultipleSubtractions() {
-        assertEquals(3, new WordProblemSolver().solve("What is 20 minus 4 minus 13?"));
+        assertEquals(3, solver.solve("What is 20 minus 4 minus 13?"));
     }
 
     @Ignore
     @Test
     public void testSubtractionThenAddition() {
-        assertEquals(14, new WordProblemSolver().solve("What is 17 minus 6 plus 3?"));
+        assertEquals(14, solver.solve("What is 17 minus 6 plus 3?"));
     }
 
     @Ignore
     @Test
     public void testMultipleMultiplications() {
-        assertEquals(-12, new WordProblemSolver().solve("What is 2 multiplied by -2 multiplied by 3?"));
+        assertEquals(-12, solver.solve("What is 2 multiplied by -2 multiplied by 3?"));
     }
 
     @Ignore
     @Test
     public void testAdditionThenMultiplication() {
-        assertEquals(-8, new WordProblemSolver().solve("What is -3 plus 7 multiplied by -2?"));
+        assertEquals(-8, solver.solve("What is -3 plus 7 multiplied by -2?"));
     }
 
     @Ignore
     @Test
     public void testMultipleDivisions() {
-        assertEquals(2, new WordProblemSolver().solve("What is -12 divided by 2 divided by -3?"));
+        assertEquals(2, solver.solve("What is -12 divided by 2 divided by -3?"));
     }
 
     @Ignore
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("I'm sorry, I don't understand the question!");
 
-        new WordProblemSolver().solve("What is 52 cubed?");
+        solver.solve("What is 52 cubed?");
     }
 
     @Ignore
         expectedException.expectMessage("I'm sorry, I don't understand the question!");
 
         // See https://en.wikipedia.org/wiki/President_of_the_United_States if you really need to know!
-        new WordProblemSolver().solve("Who is the President of the United States?");
+        solver.solve("Who is the President of the United States?");
     }
 
 }