Add new exercise Error Handling (#1338)

* Add new exercise Error Handling

* Add requested changes

* Undo unnecessary change to ErrorHandlingTest.java

* Add requested changes

* Add requested changes

* Check exception message

* Add requested changes to ErrorHandlingTest.java

* Add hints.md

* Add requested suggestions

* Expand hints.md

* Add gramatical suggestions

config.json

     {
       "core": false,
       "difficulty": 4,
+      "slug": "error-handling",
+      "topics": [
+        "exception_handling",
+        "optional_values"
+      ],
+      "unlocked_by": "triangle",
+      "uuid": "846ae792-7ca7-43e1-b523-bb1ec9fa08eb"
+    },
+    {
+      "core": false,
+      "difficulty": 4,
       "slug": "diamond",
       "topics": [
         "arrays",

exercises/error-handling/.meta/hints.md

+This exercise requires you to handle exceptions. An [exception](https://docs.oracle.com/javase/tutorial/essential/exceptions/definition.html) is an event, which occurs during the execution of a program, that disrupts the normal flow of the program's instructions.
+
+In Java, there are two types of exceptions: checked and unchecked exceptions.
+
+- [Checked vs Unchecked Exceptions in Java](https://www.geeksforgeeks.org/checked-vs-unchecked-exceptions-in-java/)
+
+- [Unchecked Exceptions — The Controversy](https://docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html)
+
+## Checked exceptions
+
+Checked exceptions are the exceptions that are checked at [compile time](https://en.wikipedia.org/wiki/Compile_time).
+
+### Practical implications
+
+You have to declare them in the [method signature](https://docs.oracle.com/javase/tutorial/java/javaOO/methods.html) of any method that can [throw](https://docs.oracle.com/javase/tutorial/essential/exceptions/throwing.html) a checked exception and handle or rethrow them when calling any method that can throw a checked exception.
+
+This is because checked exceptions are meant to be handled at runtime, i.e. they are errors you can recover from.
+
+### Examples of where they are used
+
+They're often used when a method can't return any valid result, for example a search method which hasn't found the item it was searching for.
+
+It's an alternative to returning null or a error code. A checked exception is better than those alternatives because it forces the user of the method to consider the error case.
+
+## Unchecked exceptions
+
+Unchecked exceptions are the exceptions that are not checked at [compile time](https://en.wikipedia.org/wiki/Compile_time).
+
+### Practical implications
+
+You don't have to declare them in the [method signature](https://docs.oracle.com/javase/tutorial/java/javaOO/methods.html) of methods that can [throw](https://docs.oracle.com/javase/tutorial/essential/exceptions/throwing.html) an unchecked exception and handle or rethrow them when calling any method that can throw an unchecked exception.
+
+### Examples of where they are used
+
+Unchecked exceptions are mean to be used for any error than can't be handled at runtime, e.g. running out of memory.

exercises/error-handling/.meta/src/reference/java/CustomCheckedException.java

+class CustomCheckedException extends Exception {
+
+    CustomCheckedException() {
+        super();
+    }
+
+    CustomCheckedException(String message) {
+        super(message);
+    }
+
+}

exercises/error-handling/.meta/src/reference/java/CustomUncheckedException.java

+class CustomUncheckedException extends RuntimeException {
+
+    CustomUncheckedException() {
+        super();
+    }
+
+    CustomUncheckedException(String message) {
+        super(message);
+    }
+
+}

exercises/error-handling/.meta/src/reference/java/ErrorHandling.java

+import java.io.IOException;
+import java.util.Optional;
+
+class ErrorHandling {
+
+    void handleErrorByThrowingIllegalArgumentException() {
+        throw new IllegalArgumentException();
+    }
+
+    void handleErrorByThrowingIllegalArgumentExceptionWithDetailMessage(String message) {
+        throw new IllegalArgumentException(message);
+    }
+
+    void handleErrorByThrowingAnyCheckedException() throws IOException {
+        throw new IOException();
+    }
+
+    void handleErrorByThrowingAnyCheckedExceptionWithDetailMessage(String message) throws IOException {
+        throw new IOException(message);
+    }
+
+    void handleErrorByThrowingAnyUncheckedException() {
+        throw new NullPointerException();
+    }
+
+    void handleErrorByThrowingAnyUncheckedExceptionWithDetailMessage(String message) {
+        throw new NullPointerException(message);
+    }
+
+    void handleErrorByThrowingCustomCheckedException() throws CustomCheckedException {
+        throw new CustomCheckedException();
+    }
+
+    void handleErrorByThrowingCustomCheckedExceptionWithDetailMessage(String message) throws CustomCheckedException {
+        throw new CustomCheckedException(message);
+    }
+
+    void handleErrorByThrowingCustomUncheckedException() {
+        throw new CustomUncheckedException();
+    }
+
+    void handleErrorByThrowingCustomUncheckedExceptionWithDetailMessage(String message) {
+        throw new CustomUncheckedException(message);
+    }
+
+    Optional<Integer> handleErrorByReturningOptionalInstance(String integer) {
+        if (tryParseInt(integer)) {
+            return Optional.of(Integer.parseInt(integer));
+        } else {
+            return Optional.empty();
+        }
+    }
+
+    private boolean tryParseInt(String integer) {
+        try {
+            Integer.parseInt(integer);
+            return true;
+        } catch (NumberFormatException e) {
+            return false;
+        }
+    }
+
+}

exercises/error-handling/README.md

+# Error Handling
+
+Implement various kinds of error handling and resource management.
+
+An important point of programming is how to handle errors and close
+resources even if errors occur.
+
+This exercise requires you to handle various errors. Because error handling
+is rather programming language specific you'll have to refer to the tests
+for your track to see what's exactly required.
+
+# Running the tests
+
+You can run all the tests for an exercise by entering
+
+```sh
+$ gradle test
+```
+
+in your terminal.
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

exercises/error-handling/build.gradle

+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.12"
+}
+
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/error-handling/src/main/java/CustomCheckedException.java

+class CustomCheckedException extends Exception {
+
+    CustomCheckedException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    CustomCheckedException(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

exercises/error-handling/src/main/java/CustomUncheckedException.java

+class CustomUncheckedException extends RuntimeException {
+
+    CustomUncheckedException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    CustomUncheckedException(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

exercises/error-handling/src/main/java/ErrorHandling.java

+import java.util.Optional;
+
+class ErrorHandling {
+
+    void handleErrorByThrowingIllegalArgumentException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingIllegalArgumentExceptionWithDetailMessage(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingAnyCheckedException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingAnyCheckedExceptionWithDetailMessage(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingAnyUncheckedException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingAnyUncheckedExceptionWithDetailMessage(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingCustomCheckedException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingCustomCheckedExceptionWithDetailMessage(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingCustomUncheckedException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingCustomUncheckedExceptionWithDetailMessage(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    Optional<Integer> handleErrorByReturningOptionalInstance(String integer) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

exercises/error-handling/src/test/java/ErrorHandlingTest.java

+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Optional;
+
+public class ErrorHandlingTest {
+
+    private ErrorHandling errorHandling;
+
+    @Rule
+    public ExpectedException thrown = ExpectedException.none();
+
+    @Before
+    public void setUp() {
+        errorHandling = new ErrorHandling();
+    }
+
+    @Test
+    public void testThrowIllegalArgumentException() {
+        thrown.expect(IllegalArgumentException.class);
+        errorHandling.handleErrorByThrowingIllegalArgumentException();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowIllegalArgumentExceptionWithDetailMessage() {
+        thrown.expect(IllegalArgumentException.class);
+        thrown.expectMessage("This is the detail message.");
+        errorHandling.handleErrorByThrowingIllegalArgumentExceptionWithDetailMessage("This is the detail message.");
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowAnyCheckedException() {
+        try {
+            errorHandling.handleErrorByThrowingAnyCheckedException();
+        } catch (Exception e) {
+            assertFalse(e instanceof RuntimeException);
+        }
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowAnyCheckedExceptionWithDetailMessage() {
+        try {
+            errorHandling.handleErrorByThrowingAnyCheckedExceptionWithDetailMessage("This is the detail message.");
+        } catch (Exception e) {
+            assertFalse(e instanceof RuntimeException);
+            assertEquals("This is the detail message.", e.getMessage());
+        }
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowAnyUncheckedException() {
+        thrown.expect(RuntimeException.class);
+        errorHandling.handleErrorByThrowingAnyUncheckedException();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowAnyUncheckedExceptionWithDetailMessage() {
+        thrown.expect(RuntimeException.class);
+        thrown.expectMessage("This is the detail message.");
+        errorHandling.handleErrorByThrowingAnyUncheckedExceptionWithDetailMessage("This is the detail message.");
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowCustomCheckedException() throws CustomCheckedException {
+        thrown.expect(CustomCheckedException.class);
+        errorHandling.handleErrorByThrowingCustomCheckedException();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowCustomCheckedExceptionWithDetailMessage() throws CustomCheckedException {
+        thrown.expect(CustomCheckedException.class);
+        thrown.expectMessage("This is the detail message.");
+        errorHandling.handleErrorByThrowingCustomCheckedExceptionWithDetailMessage("This is the detail message.");
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowCustomUncheckedException() {
+        thrown.expect(CustomUncheckedException.class);
+        errorHandling.handleErrorByThrowingCustomUncheckedException();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowCustomUncheckedExceptionWithDetailMessage() {
+        thrown.expect(CustomUncheckedException.class);
+        thrown.expectMessage("This is the detail message.");
+        errorHandling.handleErrorByThrowingCustomUncheckedExceptionWithDetailMessage("This is the detail message.");
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testReturnOptionalInstance() {
+        Optional<Integer> successfulResult = errorHandling.handleErrorByReturningOptionalInstance("1");
+        assertTrue(successfulResult.isPresent());
+        assertEquals(1, (int) successfulResult.get());
+
+        Optional<Integer> failureResult = errorHandling.handleErrorByReturningOptionalInstance("a");
+        assertFalse(failureResult.isPresent());
+    }
+
+}

exercises/settings.gradle

 include 'diamond'
 include 'difference-of-squares'
 include 'diffie-hellman'
+include 'error-handling'
 include 'etl'
 include 'flatten-array'
 include 'food-chain'