Merge pull request #9 from eugenp/master

update with origin

core-java-modules/core-java-exceptions/README.md

@@ -0,0 +1,3 @@
+## Relevant Articles:
+
+- [Will an Error Be Caught by Catch Block in Java?](https://www.baeldung.com/java-error-catch)

core-java-modules/core-java-exceptions/pom.xml

@@ -0,0 +1,35 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<groupId>com.baeldung.exception.numberformat</groupId>
+	<artifactId>core-java-exceptions</artifactId>
+	<version>0.0.1-SNAPSHOT</version>
+	<name>core-java-exceptions</name>
+
+	<parent>
+		<groupId>com.baeldung</groupId>
+		<artifactId>parent-java</artifactId>
+		<version>0.0.1-SNAPSHOT</version>
+		<relativePath>../../parent-java</relativePath>
+	</parent>
+
+	<dependencies>
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>${junit.version}</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.commons</groupId>
+			<artifactId>commons-lang3</artifactId>
+			<version>${commons-lang3.version}</version>
+		</dependency>
+	</dependencies>
+
+	<properties>
+		<commons-lang3.version>3.9</commons-lang3.version>
+	</properties>
+
+</project>

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/CheckedUncheckedExceptions.java

@@ -0,0 +1,43 @@
+package com.baeldung.exceptions;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+
+public class CheckedUncheckedExceptions {
+    public static void checkedExceptionWithThrows() throws FileNotFoundException {
+        File file = new File("not_existing_file.txt");
+        FileInputStream stream = new FileInputStream(file);
+    }
+
+    public static void checkedExceptionWithTryCatch() {
+        File file = new File("not_existing_file.txt");
+        try {
+            FileInputStream stream = new FileInputStream(file);
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static int divideByZero() {
+        int numerator = 1;
+        int denominator = 0;
+        return numerator / denominator;
+    }
+
+    public static void checkFile(String fileName) throws IncorrectFileNameException {
+        if (fileName == null || fileName.isEmpty()) {
+            throw new NullOrEmptyException("The filename is null.");
+        }
+        if (!isCorrectFileName(fileName)) {
+            throw new IncorrectFileNameException("Incorrect filename : " + fileName);
+        }
+    }
+
+    private static boolean isCorrectFileName(String fileName) {
+        if (fileName.equals("wrongFileName.txt"))
+            return false;
+        else
+            return true;
+    }
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/IncorrectFileNameException.java

@@ -0,0 +1,13 @@
+package com.baeldung.exceptions;
+
+public class IncorrectFileNameException extends Exception {
+    private static final long serialVersionUID = 1L;
+
+    public IncorrectFileNameException(String errorMessage) {
+        super(errorMessage);
+    }
+
+    public IncorrectFileNameException(String errorMessage, Throwable thr) {
+        super(errorMessage, thr);
+    }
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/NullOrEmptyException.java

@@ -0,0 +1,14 @@
+package com.baeldung.exceptions;
+
+public class NullOrEmptyException extends RuntimeException {
+
+    private static final long serialVersionUID = 1L;
+
+    public NullOrEmptyException(String errorMessage) {
+        super(errorMessage);
+    }
+
+    public NullOrEmptyException(String errorMessage, Throwable thr) {
+        super(errorMessage, thr);
+    }
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/RootCauseFinder.java

@@ -0,0 +1,98 @@
+package com.baeldung.exceptions;
+
+import java.time.LocalDate;
+import java.time.Period;
+import java.time.format.DateTimeParseException;
+import java.util.Objects;
+
+/**
+ * Utility class to find root cause exceptions.
+ */
+public class RootCauseFinder {
+
+    private RootCauseFinder() {
+    }
+
+    public static Throwable findCauseUsingPlainJava(Throwable throwable) {
+        Objects.requireNonNull(throwable);
+        Throwable rootCause = throwable;
+        while (rootCause.getCause() != null && rootCause.getCause() != rootCause) {
+            rootCause = rootCause.getCause();
+        }
+        return rootCause;
+    }
+
+    /**
+     *  Calculates the age of a person from a given date.
+     */
+    static class AgeCalculator {
+
+        private AgeCalculator() {
+        }
+
+        public static int calculateAge(String birthDate) {
+            if (birthDate == null || birthDate.isEmpty()) {
+                throw new IllegalArgumentException();
+            }
+
+            try {
+                return Period
+                  .between(parseDate(birthDate), LocalDate.now())
+                  .getYears();
+            } catch (DateParseException ex) {
+                throw new CalculationException(ex);
+            }
+        }
+
+        private static LocalDate parseDate(String birthDateAsString) {
+
+            LocalDate birthDate;
+            try {
+                birthDate = LocalDate.parse(birthDateAsString);
+            } catch (DateTimeParseException ex) {
+                throw new InvalidFormatException(birthDateAsString, ex);
+            }
+
+            if (birthDate.isAfter(LocalDate.now())) {
+                throw new DateOutOfRangeException(birthDateAsString);
+            }
+
+            return birthDate;
+        }
+
+    }
+
+    static class CalculationException extends RuntimeException {
+
+        CalculationException(DateParseException ex) {
+            super(ex);
+        }
+    }
+
+    static class DateParseException extends RuntimeException {
+
+        DateParseException(String input) {
+            super(input);
+        }
+
+        DateParseException(String input, Throwable thr) {
+            super(input, thr);
+        }
+    }
+
+    static class InvalidFormatException extends DateParseException {
+
+        InvalidFormatException(String input, Throwable thr) {
+            super("Invalid date format: " + input, thr);
+        }
+    }
+
+    static class DateOutOfRangeException extends DateParseException {
+
+        DateOutOfRangeException(String date) {
+            super("Date out of range: " + date);
+        }
+
+    }
+
+}

core-java-modules/core-java-exceptions/src/test/java/com/baeldung/exception/error/ErrorGeneratorUnitTest.java

@@ -0,0 +1,25 @@
+package com.baeldung.exception.error;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ErrorGeneratorUnitTest {
+
+    @Test(expected = AssertionError.class)
+    public void whenError_thenIsNotCaughtByCatchException() {
+        try {
+            throw new AssertionError();
+        } catch (Exception e) {
+            Assert.fail(); // errors are not caught by catch exception
+        }
+    }
+
+    @Test
+    public void whenError_thenIsCaughtByCatchError() {
+        try {
+            throw new AssertionError();
+        } catch (Error e) {
+            // caught! -> test pass
+        }
+    }
+}

core-java-modules/core-java-exceptions/src/test/java/com/baeldung/exception/numberformat/NumberFormatExceptionUnitTest.java

@@ -0,0 +1,154 @@
+package com.baeldung.exception.numberformat;
+
+import static org.junit.Assert.assertEquals;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.text.NumberFormat;
+import java.text.ParseException;
+import java.util.Locale;
+import java.util.logging.Logger;
+
+import org.junit.Test;
+
+/**
+ * A set of examples tested to show cases where NumberFormatException is thrown and not thrown.
+ */
+public class NumberFormatExceptionUnitTest {
+
+    Logger LOG = Logger.getLogger(NumberFormatExceptionUnitTest.class.getName());
+
+    /* ---INTEGER FAIL CASES--- */
+    @Test(expected = NumberFormatException.class)
+    public void givenByteConstructor_whenAlphabetAsInput_thenFail() {
+        Byte byteInt = new Byte("one");
+    }
+
+    @Test(expected = NumberFormatException.class)
+    public void givenShortConstructor_whenSpaceInInput_thenFail() {
+        Short shortInt = new Short("2 ");
+    }
+
+    @Test(expected = NumberFormatException.class)
+    public void givenParseIntMethod_whenSpaceInInput_thenFail() {
+        Integer aIntPrim = Integer.parseInt("6000 ");
+    }
+
+    @Test(expected = NumberFormatException.class)
+    public void givenParseIntMethod_whenUnderscoreInInput_thenFail() {
+        int bIntPrim = Integer.parseInt("_6000");
+    }
+
+    @Test(expected = NumberFormatException.class)
+    public void givenIntegerValueOfMethod_whenCommaInInput_thenFail() {
+        Integer cIntPrim = Integer.valueOf("6,000");
+    }
+
+    @Test(expected = NumberFormatException.class)
+    public void givenBigIntegerConstructor_whenDecimalInInput_thenFail() {
+        BigInteger bigInteger = new BigInteger("4.0");
+    }
+
+    @Test(expected = NumberFormatException.class)
+    public void givenDecodeMethod_whenAlphabetInInput_thenFail() {
+        Long decodedLong = Long.decode("64403L");
+    }
+
+    /* ---INTEGER PASS CASES--- */
+    @Test
+    public void givenInvalidNumberInputs_whenOptimized_thenPass() {
+        Byte byteInt = new Byte("1");
+        assertEquals(1, byteInt.intValue());
+
+        Short shortInt = new Short("2 ".trim());
+        assertEquals(2, shortInt.intValue());
+
+        Integer aIntObj = Integer.valueOf("6");
+        assertEquals(6, aIntObj.intValue());
+
+        BigInteger bigInteger = new BigInteger("4");
+        assertEquals(4, bigInteger.intValue());
+
+        int aIntPrim = Integer.parseInt("6000 ".trim());
+        assertEquals(6000, aIntPrim);
+
+        int bIntPrim = Integer.parseInt("_6000".replaceAll("_", ""));
+        assertEquals(6000, bIntPrim);
+
+        int cIntPrim = Integer.parseInt("-6000");
+        assertEquals(-6000, cIntPrim);
+
+        Long decodeInteger = Long.decode("644032334");
+        assertEquals(644032334L, decodeInteger.longValue());
+    }
+
+    /* ---DOUBLE FAIL CASES--- */
+    @Test(expected = NumberFormatException.class)
+    public void givenFloatConstructor_whenAlphabetInInput_thenFail() {
+        Float floatDecimalObj = new Float("one.1");
+    }
+
+    @Test(expected = NumberFormatException.class)
+    public void givenDoubleConstructor_whenAlphabetInInput_thenFail() {
+        Double doubleDecimalObj = new Double("two.2");
+    }
+
+    @Test(expected = NumberFormatException.class)
+    public void givenBigDecimalConstructor_whenSpecialCharsInInput_thenFail() {
+        BigDecimal bigDecimalObj = new BigDecimal("3_0.3");
+    }
+
+    @Test(expected = NumberFormatException.class)
+    public void givenParseDoubleMethod_whenCommaInInput_thenFail() {
+        double aDoublePrim = Double.parseDouble("4000,1");
+    }
+
+    /* ---DOUBLE PASS CASES--- */
+    @Test
+    public void givenDoubleConstructor_whenDecimalInInput_thenPass() {
+        Double doubleDecimalObj = new Double("2.2");
+        assertEquals(2.2, doubleDecimalObj.doubleValue(), 0);
+    }
+
+    @Test
+    public void givenDoubleValueOfMethod_whenMinusInInput_thenPass() {
+        Double aDoubleObj = Double.valueOf("-6000");
+        assertEquals(-6000, aDoubleObj.doubleValue(), 0);
+    }
+
+    @Test
+    public void givenUsDecimalNumber_whenParsedWithNumberFormat_thenPass() throws ParseException {
+        Number parsedNumber = parseNumberWithLocale("4000.1", Locale.US);
+        assertEquals(4000.1, parsedNumber);
+        assertEquals(4000.1, parsedNumber.doubleValue(), 0);
+        assertEquals(4000, parsedNumber.intValue());
+    }
+
+    /**
+     * In most European countries (for example, France), comma is used as decimal in place of period.
+     * @throws ParseException if the input string contains special characters other than comma or decimal. 
+     * In this test case, anything after decimal (period) is dropped when a European locale is set.
+     */
+    @Test
+    public void givenEuDecimalNumberHasComma_whenParsedWithNumberFormat_thenPass() throws ParseException {
+        Number parsedNumber = parseNumberWithLocale("4000,1", Locale.FRANCE);
+        LOG.info("Number parsed is: " + parsedNumber);
+        assertEquals(4000.1, parsedNumber);
+        assertEquals(4000.1, parsedNumber.doubleValue(), 0);
+        assertEquals(4000, parsedNumber.intValue());
+    }
+
+    /**
+     * Converts a string into a number retaining all decimals, and symbols valid in a locale.
+     * @param number the input string for a number.
+     * @param locale the locale to consider while parsing a number.
+     * @return the generic number object which can represent multiple number types.
+     * @throws ParseException when input contains invalid characters.
+     */
+    private Number parseNumberWithLocale(String number, Locale locale) throws ParseException {
+        locale = locale == null ? Locale.getDefault() : locale;
+        NumberFormat numberFormat = NumberFormat.getInstance(locale);
+        return numberFormat.parse(number);
+    }
+
+}

core-java-modules/core-java-exceptions/src/test/java/com/baeldung/exceptions/CheckedUncheckedExceptionsUnitTest.java

@@ -0,0 +1,55 @@
+package com.baeldung.exceptions;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.FileNotFoundException;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests the {@link CheckedUncheckedExceptions}.
+ */
+public class CheckedUncheckedExceptionsUnitTest {
+
+    @Test
+    public void whenFileNotExist_thenThrowException() {
+        assertThrows(FileNotFoundException.class, () -> {
+            CheckedUncheckedExceptions.checkedExceptionWithThrows();
+        });
+    }
+
+    @Test
+    public void whenTryCatchExcetpion_thenSuccess() {
+        try {
+            CheckedUncheckedExceptions.checkedExceptionWithTryCatch();
+        } catch (Exception e) {
+            Assertions.fail(e.getMessage());
+        }
+    }
+
+    @Test
+    public void whenDivideByZero_thenThrowException() {
+        assertThrows(ArithmeticException.class, () -> {
+            CheckedUncheckedExceptions.divideByZero();
+        });
+    }
+
+    @Test
+    public void whenInvalidFile_thenThrowException() {
+
+        assertThrows(IncorrectFileNameException.class, () -> {
+            CheckedUncheckedExceptions.checkFile("wrongFileName.txt");
+        });
+    }
+
+    @Test
+    public void whenNullOrEmptyFile_thenThrowException() {
+        assertThrows(NullOrEmptyException.class, () -> {
+            CheckedUncheckedExceptions.checkFile(null);
+        });
+        assertThrows(NullOrEmptyException.class, () -> {
+            CheckedUncheckedExceptions.checkFile("");
+        });
+    }
+}

core-java-modules/core-java-exceptions/src/test/java/com/baeldung/exceptions/RootCauseFinderUnitTest.java

@@ -0,0 +1,114 @@
+package com.baeldung.exceptions;
+
+import com.google.common.base.Throwables;
+import org.apache.commons.lang3.exception.ExceptionUtils;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeParseException;
+import java.time.temporal.ChronoUnit;
+
+import static com.baeldung.exceptions.RootCauseFinder.*;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Tests the {@link RootCauseFinder}.
+ */
+public class RootCauseFinderUnitTest {
+
+    @Test
+    public void givenBirthDate_whenCalculatingAge_thenAgeReturned() {
+        try {
+            int age = AgeCalculator.calculateAge("1990-01-01");
+            Assertions.assertEquals(1990, LocalDate
+              .now()
+              .minus(age, ChronoUnit.YEARS)
+              .getYear());
+        } catch (CalculationException e) {
+            Assertions.fail(e.getMessage());
+        }
+    }
+
+    @Test
+    public void givenWrongFormatDate_whenFindingRootCauseUsingJava_thenRootCauseFound() {
+        try {
+            AgeCalculator.calculateAge("010102");
+        } catch (CalculationException ex) {
+            assertTrue(findCauseUsingPlainJava(ex) instanceof DateTimeParseException);
+        }
+    }
+
+    @Test
+    public void givenOutOfRangeDate_whenFindingRootCauseUsingJava_thenRootCauseFound() {
+        try {
+            AgeCalculator.calculateAge("2020-04-04");
+        } catch (CalculationException ex) {
+            assertTrue(findCauseUsingPlainJava(ex) instanceof DateOutOfRangeException);
+        }
+    }
+
+    @Test
+    public void givenNullDate_whenFindingRootCauseUsingJava_thenRootCauseFound() {
+        try {
+            AgeCalculator.calculateAge(null);
+        } catch (Exception ex) {
+            assertTrue(findCauseUsingPlainJava(ex) instanceof IllegalArgumentException);
+        }
+    }
+
+    @Test
+    public void givenWrongFormatDate_whenFindingRootCauseUsingApacheCommons_thenRootCauseFound() {
+        try {
+            AgeCalculator.calculateAge("010102");
+        } catch (CalculationException ex) {
+            assertTrue(ExceptionUtils.getRootCause(ex) instanceof DateTimeParseException);
+        }
+    }
+
+    @Test
+    public void givenOutOfRangeDate_whenFindingRootCauseUsingApacheCommons_thenRootCauseFound() {
+        try {
+            AgeCalculator.calculateAge("2020-04-04");
+        } catch (CalculationException ex) {
+            assertTrue(ExceptionUtils.getRootCause(ex) instanceof DateOutOfRangeException);
+        }
+    }
+
+    @Test
+    public void givenNullDate_whenFindingRootCauseUsingApacheCommons_thenRootCauseNotFound() {
+        try {
+            AgeCalculator.calculateAge(null);
+        } catch (Exception ex) {
+            assertTrue(ExceptionUtils.getRootCause(ex) instanceof IllegalArgumentException);
+        }
+    }
+
+    @Test
+    public void givenWrongFormatDate_whenFindingRootCauseUsingGuava_thenRootCauseFound() {
+        try {
+            AgeCalculator.calculateAge("010102");
+        } catch (CalculationException ex) {
+            assertTrue(Throwables.getRootCause(ex) instanceof DateTimeParseException);
+        }
+    }
+
+    @Test
+    public void givenOutOfRangeDate_whenFindingRootCauseUsingGuava_thenRootCauseFound() {
+        try {
+            AgeCalculator.calculateAge("2020-04-04");
+        } catch (CalculationException ex) {
+            assertTrue(Throwables.getRootCause(ex) instanceof DateOutOfRangeException);
+        }
+    }
+
+    @Test
+    public void givenNullDate_whenFindingRootCauseUsingGuava_thenRootCauseFound() {
+        try {
+            AgeCalculator.calculateAge(null);
+        } catch (Exception ex) {
+            assertTrue(Throwables.getRootCause(ex) instanceof IllegalArgumentException);
+        }
+    }
+
+}