Merge branch 'master' into JourneyTestMakeWorkWithExercises

exercises/linked-list/src/example/java/Deque.java → exercises/linked-list/src/example/java/DoublyLinkedList.java

-public final class Deque<T> {
+public final class DoublyLinkedList<T> {
     private Element<T> head;
 
     public void push(T value) {

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

 import static org.hamcrest.CoreMatchers.*;
 import static org.junit.Assert.*;
 
-public class DequeTest {
-    private Deque<Integer> subject;
+public class DoublyLinkedListTest {
+    private DoublyLinkedList<Integer> subject;
 
     @Before
     public void setUp() {
-        subject = new Deque<>();
+        subject = new DoublyLinkedList<>();
     }
 
 

exercises/phone-number/src/example/java/PhoneNumber.java

     }
 
     private String extractDigits(String dirtyNumber) {
-        return dirtyNumber.replaceAll("[^\\d]", "");
+        StringBuilder stringBuilder = new StringBuilder();
+        for (char c : dirtyNumber.toCharArray()) {
+            if (c == ' ' || c == '.' || c == '(' || c == ')' || c == '-') {
+                // Remove spaces, dots, parentheses and hyphens
+                continue;
+            }
+            if (!Character.isDigit(c)) {
+                throw new IllegalArgumentException("Illegal character in phone number. "
+                        + "Only digits, spaces, parentheses, hyphens or dots accepted.");
+            }
+            stringBuilder.append(c);
+        }
+        return stringBuilder.toString();
     }
 
     private String normalize(String number) {
-        if(number.length() > 11 || number.length() < 10){
+        if (number.length() > 11 || number.length() < 10) {
             throw new IllegalArgumentException("Number must be 10 or 11 digits");
         }
 
-        if(number.length() == 11){
-            if(number.startsWith("1")){
+        if (number.length() == 11) {
+            if (number.startsWith("1")) {
                 number = number.substring(1, number.length());
-            }
-            else{
+            } else {
                 throw new IllegalArgumentException("Can only have 11 digits if number starts with '1'");
             }
-        } 
-        
+        }
+
         return number;
     }
 
     public String getNumber() {
         return number;
     }
-
-    public String getAreaCode() {
-        return number.substring(0, 3);
-    }
-
-    public String getExchangeCode() {
-        return number.substring(3, 6);
-    }
-
-    public String getSubscriberNumber() {
-        return number.substring(6, 10);
-    }
-
-    public String pretty() {
-        return "(" + getAreaCode() + ") " + getExchangeCode() + "-" + getSubscriberNumber();
-    }
-
 }

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

-import org.junit.Test;
 import org.junit.Ignore;
 import org.junit.Rule;
+import org.junit.Test;
 import org.junit.rules.ExpectedException;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 public class PhoneNumberTest {
+    private final static String wrongLengthExceptionMessage = "Number must be 10 or 11 digits";
+    private final static String numberIs11DigitsButDoesNotStartWith1ExceptionMessage =
+            "Can only have 11 digits if number starts with '1'";
+    private final static String illegalCharacterExceptionMessage =
+            "Illegal character in phone number. Only digits, spaces, parentheses, hyphens or dots accepted.";
 
     @Rule
     public ExpectedException expectedException = ExpectedException.none();
         final String actualNumber = new PhoneNumber("(123) 456-7890").getNumber();
 
         assertEquals(
-            expectedNumber, actualNumber
+                expectedNumber, actualNumber
         );
     }
 
         final String actualNumber = new PhoneNumber("123.456.7890").getNumber();
 
         assertEquals(
-            expectedNumber, actualNumber
+                expectedNumber, actualNumber
         );
     }
 
     @Ignore
     @Test
-    public void validWhen11DigitsAndFirstIs1() {
+    public void cleansNumberWithMultipleSpaces() {
         final String expectedNumber = "1234567890";
-        final String actualNumber = new PhoneNumber("11234567890").getNumber();
+        final String actualNumber = new PhoneNumber("123 456   7890   ").getNumber();
 
         assertEquals(
-            expectedNumber, actualNumber
+                expectedNumber, actualNumber
         );
     }
 
     @Ignore
     @Test
-    public void invalidWhenOnly11Digits() {
+    public void invalidWhen9Digits() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Can only have 11 digits if number starts with '1'");
-        new PhoneNumber("21234567890").getNumber();
+        expectedException.expectMessage(wrongLengthExceptionMessage);
+        new PhoneNumber("123456789");
     }
 
     @Ignore
     @Test
-    public void invalidWhen9Digits() {
+    public void invalidWhen11Digits() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Number must be 10 or 11 digits");
-        new PhoneNumber("123456789").getNumber();
+        expectedException.expectMessage(numberIs11DigitsButDoesNotStartWith1ExceptionMessage);
+        new PhoneNumber("21234567890");
     }
 
     @Ignore
     @Test
-    public void areaCode() {
-        final String expectedAreaCode = "123";
-        final String actualAreaCode = new PhoneNumber("1234567890").getAreaCode();
+    public void validWhen11DigitsAndFirstIs1() {
+        final String expectedNumber = "1234567890";
+        final String actualNumber = new PhoneNumber("11234567890").getNumber();
 
         assertEquals(
-            expectedAreaCode, actualAreaCode
+                expectedNumber, actualNumber
         );
     }
 
     @Ignore
     @Test
-    public void prettyPrint() {
-        final String expectedPrettyNumber = "(123) 456-7890";
-        final String actualPrettyNumber = new PhoneNumber("1234567890").pretty();
-
-        assertEquals(
-            expectedPrettyNumber, actualPrettyNumber
-        );
+    public void invalidWhen12Digits() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage(wrongLengthExceptionMessage);
+        new PhoneNumber("321234567890");
     }
 
     @Ignore
     @Test
-    public void prettyPrintWithFullUSPhoneNumber() {
-        final String expectedPrettyNumber = "(123) 456-7890";
-        final String actualPrettyNumber = new PhoneNumber("11234567890").pretty();
+    public void invalidWithLetters() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage(illegalCharacterExceptionMessage);
+        new PhoneNumber("123-abc-7890");
+    }
 
-        assertEquals(
-            expectedPrettyNumber, actualPrettyNumber
-        );
+    @Ignore
+    @Test
+    public void invalidWithPunctuation() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage(illegalCharacterExceptionMessage);
+        new PhoneNumber("123-@:!-7890");
     }
 
+    @Ignore
+    @Test
+    public void invalidWithRightNumberOfDigitsButLettersMixedIn() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage(illegalCharacterExceptionMessage);
+        new PhoneNumber("1a2b3c4d5e6f7g8h9i0j");
+    }
 }