Merge branch 'master' into BAEL-3660_Open_Liberty

# Conflicts:
#	pom.xml

akka-http/src/test/java/com/baeldung/akkahttp/UserServerUnitTest.java

@@ -7,6 +7,8 @@ import akka.http.javadsl.model.HttpEntities;
 import akka.http.javadsl.model.HttpRequest;
 import akka.http.javadsl.testkit.JUnitRouteTest;
 import akka.http.javadsl.testkit.TestRoute;
+
+import org.junit.Ignore;
 import org.junit.Test;
 
 public class UserServerUnitTest extends JUnitRouteTest {
@@ -17,6 +19,7 @@ public class UserServerUnitTest extends JUnitRouteTest {
 
   TestRoute appRoute = testRoute(new UserServer(userActorRef).routes());
 
+  @Ignore
   @Test
   public void whenRequest_thenActorResponds() {
 

algorithms-miscellaneous-1/pom.xml

@@ -64,7 +64,7 @@
             <plugin>
                 <groupId>org.codehaus.mojo</groupId>
                 <artifactId>cobertura-maven-plugin</artifactId>
-                <version>2.7</version>
+                <version>${cobertura.plugin.version}</version>
                 <configuration>
                     <instrumentation>
                         <ignores>
@@ -85,6 +85,7 @@
         <commons-codec.version>1.11</commons-codec.version>
         <guava.version>27.0.1-jre</guava.version>
         <combinatoricslib3.version>3.3.0</combinatoricslib3.version>
+        <cobertura.plugin.version>2.7</cobertura.plugin.version>
     </properties>
 
 </project>

algorithms-miscellaneous-3/pom.xml

@@ -46,13 +46,13 @@
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>
-            <version>3.8.1</version>
+            <version>${commons.lang3.version}</version>
         </dependency>
 
         <dependency>
             <groupId>pl.pragmatists</groupId>
             <artifactId>JUnitParams</artifactId>
-            <version>1.1.0</version>
+            <version>${JUnitParams.version}</version>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -91,6 +91,8 @@
         <retrofit.version>2.6.0</retrofit.version>
         <jmh-core.version>1.19</jmh-core.version>
         <jmh-generator.version>1.19</jmh-generator.version>
+        <commons.lang3.version>3.8.1</commons.lang3.version>
+        <JUnitParams.version>1.1.0</JUnitParams.version>
     </properties>
 
 </project>

algorithms-miscellaneous-5/pom.xml

@@ -37,7 +37,7 @@
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>
-            <version>28.1-jre</version>
+            <version>${guava.version}</version>
         </dependency>
 
         <dependency>
@@ -65,6 +65,7 @@
         <org.assertj.core.version>3.9.0</org.assertj.core.version>
         <commons-codec.version>1.11</commons-codec.version>
         <commons-math3.version>3.6.1</commons-math3.version>
+        <guava.version>28.1-jre</guava.version>
     </properties>
 
 </project>

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/HeapNode.java

@@ -0,0 +1,13 @@
+package com.baeldung.algorithms.minheapmerge;
+
+public class HeapNode {
+
+    int element;
+    int arrayIndex;
+    int nextElementIndex = 1;
+
+    public HeapNode(int element, int arrayIndex) {
+        this.element = element;
+        this.arrayIndex = arrayIndex;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeap.java

@@ -0,0 +1,88 @@
+package com.baeldung.algorithms.minheapmerge;
+
+public class MinHeap {
+
+    HeapNode[] heapNodes;
+
+    public MinHeap(HeapNode heapNodes[]) {
+        this.heapNodes = heapNodes;
+        heapifyFromLastLeafsParent();
+    }
+
+    void heapifyFromLastLeafsParent() {
+        int lastLeafsParentIndex = getParentNodeIndex(heapNodes.length);
+        while (lastLeafsParentIndex >= 0) {
+            heapify(lastLeafsParentIndex);
+            lastLeafsParentIndex--;
+        }
+    }
+
+    void heapify(int index) {
+        int leftNodeIndex = getLeftNodeIndex(index);
+        int rightNodeIndex = getRightNodeIndex(index);
+        int smallestElementIndex = index;
+        if (leftNodeIndex < heapNodes.length && heapNodes[leftNodeIndex].element < heapNodes[index].element) {
+            smallestElementIndex = leftNodeIndex;
+        }
+        if (rightNodeIndex < heapNodes.length && heapNodes[rightNodeIndex].element < heapNodes[smallestElementIndex].element) {
+            smallestElementIndex = rightNodeIndex;
+        }
+        if (smallestElementIndex != index) {
+            swap(index, smallestElementIndex);
+            heapify(smallestElementIndex);
+        }
+    }
+
+    int getParentNodeIndex(int index) {
+        return (index - 1) / 2;
+    }
+
+    int getLeftNodeIndex(int index) {
+        return (2 * index + 1);
+    }
+
+    int getRightNodeIndex(int index) {
+        return (2 * index + 2);
+    }
+
+    HeapNode getRootNode() {
+        return heapNodes[0];
+    }
+
+    void heapifyFromRoot() {
+        heapify(0);
+    }
+
+    void swap(int i, int j) {
+        HeapNode temp = heapNodes[i];
+        heapNodes[i] = heapNodes[j];
+        heapNodes[j] = temp;
+    }
+    
+    static int[] merge(int[][] array) {
+        HeapNode[] heapNodes = new HeapNode[array.length];
+        int resultingArraySize = 0;
+
+        for (int i = 0; i < array.length; i++) {
+            HeapNode node = new HeapNode(array[i][0], i);
+            heapNodes[i] = node;
+            resultingArraySize += array[i].length;
+        }
+        
+        MinHeap minHeap = new MinHeap(heapNodes);
+        int[] resultingArray = new int[resultingArraySize];
+
+        for (int i = 0; i < resultingArraySize; i++) {
+            HeapNode root = minHeap.getRootNode();
+            resultingArray[i] = root.element;
+
+            if (root.nextElementIndex < array[root.arrayIndex].length) {
+                root.element = array[root.arrayIndex][root.nextElementIndex++];
+            } else {
+                root.element = Integer.MAX_VALUE;
+            }
+            minHeap.heapifyFromRoot();
+        }
+        return resultingArray;
+    }
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapUnitTest.java

@@ -0,0 +1,22 @@
+package com.baeldung.algorithms.minheapmerge;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import org.junit.Test;
+
+public class MinHeapUnitTest {
+
+    private final int[][] inputArray = { { 0, 6 }, { 1, 5, 10, 100 }, { 2, 4, 200, 650 } };
+    private final int[] expectedArray = { 0, 1, 2, 4, 5, 6, 10, 100, 200, 650 };
+
+    @Test
+    public void givenSortedArrays_whenMerged_thenShouldReturnASingleSortedarray() {
+        int[] resultArray = MinHeap.merge(inputArray);
+        
+        assertThat(resultArray.length, is(equalTo(10)));
+        assertThat(resultArray, is(equalTo(expectedArray)));
+    }
+    
+}

algorithms-sorting-2/.gitignore

@@ -0,0 +1,4 @@
+/target/
+.settings/
+.classpath
+.project

algorithms-sorting-2/pom.xml

@@ -0,0 +1,64 @@
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
+         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>
+    <artifactId>algorithms-sorting-2</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>algorithms-sorting-2</name>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-math3</artifactId>
+            <version>${commons-math3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-codec</groupId>
+            <artifactId>commons-codec</artifactId>
+            <version>${commons-codec.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>${junit-jupiter-api.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${org.assertj.core.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.codehaus.mojo</groupId>
+                    <artifactId>exec-maven-plugin</artifactId>
+                    <version>${exec-maven-plugin.version}</version>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+    </build>
+
+    <properties>
+        <commons-math3.version>3.6.1</commons-math3.version>
+        <org.assertj.core.version>3.9.0</org.assertj.core.version>
+        <commons-codec.version>1.11</commons-codec.version>
+        <junit-jupiter-api.version>5.3.1</junit-jupiter-api.version>
+    </properties>
+
+</project>

algorithms-sorting-2/src/main/java/com/baeldung/algorithms/quicksort/BentleyMcIlroyPartioning.java

@@ -0,0 +1,66 @@
+package com.baeldung.algorithms.quicksort;
+
+import static com.baeldung.algorithms.quicksort.SortingUtils.swap;
+
+public class BentleyMcIlroyPartioning {
+
+    public static Partition partition(int input[], int begin, int end) {
+        int left = begin, right = end;
+        int leftEqualKeysCount = 0, rightEqualKeysCount = 0;
+
+        int partitioningValue = input[end];
+
+        while (true) {
+            while (input[left] < partitioningValue)
+                left++;
+
+            while (input[right] > partitioningValue) {
+                if (right == begin)
+                    break;
+                right--;
+            }
+
+            if (left == right && input[left] == partitioningValue) {
+                swap(input, begin + leftEqualKeysCount, left);
+                leftEqualKeysCount++;
+                left++;
+            }
+
+            if (left >= right) {
+                break;
+            }
+
+            swap(input, left, right);
+
+            if (input[left] == partitioningValue) {
+                swap(input, begin + leftEqualKeysCount, left);
+                leftEqualKeysCount++;
+            }
+
+            if (input[right] == partitioningValue) {
+                swap(input, right, end - rightEqualKeysCount);
+                rightEqualKeysCount++;
+            }
+            left++; right--;
+        }
+        right = left - 1;
+        for (int k = begin; k < begin + leftEqualKeysCount; k++, right--) {
+            if (right >= begin + leftEqualKeysCount)
+                swap(input, k, right);
+        }
+        for (int k = end; k > end - rightEqualKeysCount; k--, left++) {
+            if (left <= end - rightEqualKeysCount)
+                swap(input, left, k);
+        }
+        return new Partition(right + 1, left - 1);
+    }
+
+    public static void quicksort(int input[], int begin, int end) {
+        if (end <= begin)
+            return;
+        Partition middlePartition = partition(input, begin, end);
+        quicksort(input, begin, middlePartition.getLeft() - 1);
+        quicksort(input, middlePartition.getRight() + 1, end);
+    }
+
+}

algorithms-sorting-2/src/main/java/com/baeldung/algorithms/quicksort/DutchNationalFlagPartioning.java

@@ -0,0 +1,38 @@
+package com.baeldung.algorithms.quicksort;
+
+import static com.baeldung.algorithms.quicksort.SortingUtils.compare;
+import static com.baeldung.algorithms.quicksort.SortingUtils.swap;
+
+public class DutchNationalFlagPartioning {
+
+    public static Partition partition(int[] a, int begin, int end) {
+        int lt = begin, current = begin, gt = end;
+        int partitioningValue = a[begin];
+
+        while (current <= gt) {
+            int compareCurrent = compare(a[current], partitioningValue);
+            switch (compareCurrent) {
+                case -1:
+                    swap(a, current++, lt++);
+                    break;
+                case 0:
+                    current++;
+                    break;
+                case 1:
+                    swap(a, current, gt--);
+                    break;
+            }
+        }
+        return new Partition(lt, gt);
+    }
+
+    public static void quicksort(int[] input, int begin, int end) {
+        if (end <= begin)
+            return;
+
+        Partition middlePartition = partition(input, begin, end);
+
+        quicksort(input, begin, middlePartition.getLeft() - 1);
+        quicksort(input, middlePartition.getRight() + 1, end);
+    }
+}

algorithms-sorting-2/src/main/java/com/baeldung/algorithms/quicksort/Partition.java

@@ -0,0 +1,29 @@
+package com.baeldung.algorithms.quicksort;
+
+public class Partition {
+    private int left;
+    private int right;
+
+    public Partition(int left, int right) {
+        super();
+        this.left = left;
+        this.right = right;
+    }
+
+    public int getLeft() {
+        return left;
+    }
+
+    public void setLeft(int left) {
+        this.left = left;
+    }
+
+    public int getRight() {
+        return right;
+    }
+
+    public void setRight(int right) {
+        this.right = right;
+    }
+
+}

algorithms-sorting-2/src/main/java/com/baeldung/algorithms/quicksort/SortingUtils.java

@@ -0,0 +1,32 @@
+package com.baeldung.algorithms.quicksort;
+
+public class SortingUtils {
+
+    public static void swap(int[] array, int position1, int position2) {
+        if (position1 != position2) {
+            int temp = array[position1];
+            array[position1] = array[position2];
+            array[position2] = temp;
+        }
+    }
+
+    public static int compare(int num1, int num2) {
+        if (num1 > num2)
+            return 1;
+        else if (num1 < num2)
+            return -1;
+        else
+            return 0;
+    }
+
+    public static void printArray(int[] array) {
+        if (array == null) {
+            return;
+        }
+        for (int e : array) {
+            System.out.print(e + " ");
+        }
+        System.out.println();
+    }
+
+}

algorithms-sorting-2/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT"/>
+    </root>
+</configuration>

algorithms-sorting-2/src/test/java/com/baeldung/algorithms/quicksort/BentleyMcilroyPartitioningUnitTest.java

@@ -0,0 +1,16 @@
+package com.baeldung.algorithms.quicksort;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class BentleyMcilroyPartitioningUnitTest {
+
+    @Test
+    public void given_IntegerArray_whenSortedWithBentleyMcilroyPartitioning_thenGetSortedArray() {
+        int[] actual = {3, 2, 2, 2, 3, 7, 7, 3, 2, 2, 7, 3, 3};
+        int[] expected = {2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 7, 7, 7};
+        BentleyMcIlroyPartioning.quicksort(actual, 0, actual.length - 1);
+        Assert.assertArrayEquals(expected, actual);
+    }
+
+}

algorithms-sorting-2/src/test/java/com/baeldung/algorithms/quicksort/DNFThreeWayQuickSortUnitTest.java

@@ -0,0 +1,15 @@
+package com.baeldung.algorithms.quicksort;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class DNFThreeWayQuickSortUnitTest {
+
+    @Test
+    public void givenIntegerArray_whenSortedWithThreeWayQuickSort_thenGetSortedArray() {
+        int[] actual = {3, 5, 5, 5, 3, 7, 7, 3, 5, 5, 7, 3, 3};
+        int[] expected = {3, 3, 3, 3, 3, 5, 5, 5, 5, 5, 7, 7, 7};
+        DutchNationalFlagPartioning.quicksort(actual, 0, actual.length - 1);
+        Assert.assertArrayEquals(expected, actual);
+    }
+}

apache-cxf/sse-jaxrs/sse-jaxrs-server/pom.xml

@@ -18,19 +18,19 @@
         <dependency>
             <groupId>javax.ws.rs</groupId>
             <artifactId>javax.ws.rs-api</artifactId>
-            <version>2.1</version>
+            <version>${rs-api.version}</version>
             <scope>provided</scope>
         </dependency>
         <dependency>
             <groupId>javax.enterprise</groupId>
             <artifactId>cdi-api</artifactId>
-            <version>2.0</version>
+            <version>${cdi-api.version}</version>
             <scope>provided</scope>
         </dependency>
         <dependency>
             <groupId>javax.json.bind</groupId>
             <artifactId>javax.json.bind-api</artifactId>
-            <version>1.0</version>
+            <version>${bind-api.version}</version>
             <scope>provided</scope>
         </dependency>
 
@@ -80,6 +80,9 @@
         <liberty-maven-plugin.version>2.4.2</liberty-maven-plugin.version>
         <failOnMissingWebXml>false</failOnMissingWebXml>
         <openliberty-version>18.0.0.2</openliberty-version>
+        <rs-api.version>2.1</rs-api.version>
+        <cdi-api.version>2.0</cdi-api.version>
+        <bind-api.version>1.0</bind-api.version>
     </properties>
 
 </project>

apache-poi/pom.xml

@@ -32,7 +32,7 @@
     </dependencies>
 
     <properties>
-        <poi.version>3.15</poi.version>
+        <poi.version>4.1.1</poi.version>
         <jexcel.version>1.0.6</jexcel.version>
     </properties>
 

apache-poi/src/main/java/com/baeldung/poi/excel/ExcelCellFormatter.java

@@ -0,0 +1,20 @@
+package com.baeldung.poi.excel;
+
+import org.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.DataFormatter;
+import org.apache.poi.ss.usermodel.FormulaEvaluator;
+import org.apache.poi.ss.usermodel.Workbook;
+
+public class ExcelCellFormatter {
+
+    public String getCellStringValue(Cell cell) {
+        DataFormatter formatter = new DataFormatter();
+        return formatter.formatCellValue(cell);
+    }
+
+    public String getCellStringValueWithFormula(Cell cell, Workbook workbook) {
+        DataFormatter formatter = new DataFormatter();
+        FormulaEvaluator evaluator = workbook.getCreationHelper().createFormulaEvaluator();
+        return formatter.formatCellValue(cell, evaluator);
+    }
+}

apache-poi/src/main/java/com/baeldung/poi/excel/read/cellvalueandnotformula/CellValueAndNotFormulaHelper.java

@@ -0,0 +1,83 @@
+package com.baeldung.poi.excel.read.cellvalueandnotformula;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+
+import org.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.CellType;
+import org.apache.poi.ss.usermodel.FormulaEvaluator;
+import org.apache.poi.ss.usermodel.Row;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.usermodel.Workbook;
+import org.apache.poi.ss.util.CellAddress;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+
+public class CellValueAndNotFormulaHelper {
+
+    public Object getCellValueByFetchingLastCachedValue(String fileLocation, String cellLocation) throws IOException {
+        Object cellValue = new Object();
+
+        FileInputStream inputStream = new FileInputStream(new File(fileLocation));
+        Workbook workbook = new XSSFWorkbook(inputStream);
+
+        Sheet sheet = workbook.getSheetAt(0);
+
+        CellAddress cellAddress = new CellAddress(cellLocation);
+        Row row = sheet.getRow(cellAddress.getRow());
+        Cell cell = row.getCell(cellAddress.getColumn());
+
+        if (cell.getCellType() == CellType.FORMULA) {
+            switch (cell.getCachedFormulaResultType()) {
+                case BOOLEAN:
+                    cellValue = cell.getBooleanCellValue();
+                    break;
+                case NUMERIC:
+                    cellValue = cell.getNumericCellValue();
+                    break;
+                case STRING:
+                    cellValue = cell.getStringCellValue();
+                    break;
+                default:
+                    cellValue = null;
+            }
+        }
+
+        workbook.close();
+        return cellValue;
+    }
+
+    public Object getCellValueByEvaluatingFormula(String fileLocation, String cellLocation) throws IOException {
+        Object cellValue = new Object();
+
+        FileInputStream inputStream = new FileInputStream(new File(fileLocation));
+        Workbook workbook = new XSSFWorkbook(inputStream);
+
+        Sheet sheet = workbook.getSheetAt(0);
+        FormulaEvaluator evaluator = workbook.getCreationHelper()
+            .createFormulaEvaluator();
+
+        CellAddress cellAddress = new CellAddress(cellLocation);
+        Row row = sheet.getRow(cellAddress.getRow());
+        Cell cell = row.getCell(cellAddress.getColumn());
+
+        if (cell.getCellType() == CellType.FORMULA) {
+            switch (evaluator.evaluateFormulaCell(cell)) {
+                case BOOLEAN:
+                    cellValue = cell.getBooleanCellValue();
+                    break;
+                case NUMERIC:
+                    cellValue = cell.getNumericCellValue();
+                    break;
+                case STRING:
+                    cellValue = cell.getStringCellValue();
+                    break;
+                default:
+                    cellValue = null;
+            }
+        }
+
+        workbook.close();
+        return cellValue;
+    }
+}

apache-poi/src/test/java/com/baeldung/poi/excel/ExcelCellFormatterUnitTest.java

@@ -0,0 +1,87 @@
+package com.baeldung.poi.excel;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.nio.file.Paths;
+
+import org.apache.poi.ss.usermodel.Row;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.usermodel.Workbook;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+import org.junit.Before;
+import org.junit.Test;
+
+public class ExcelCellFormatterUnitTest {
+    private static final String FILE_NAME = "ExcelCellFormatterTest.xlsx";
+    private static final int STRING_CELL_INDEX = 0;
+    private static final int BOOLEAN_CELL_INDEX = 1;
+    private static final int RAW_NUMERIC_CELL_INDEX = 2;
+    private static final int FORMATTED_NUMERIC_CELL_INDEX = 3;
+    private static final int FORMULA_CELL_INDEX = 4;
+
+    private String fileLocation;
+
+    @Before
+    public void setup() throws IOException, URISyntaxException {
+            fileLocation = Paths.get(ClassLoader.getSystemResource(FILE_NAME).toURI()).toString();
+    }
+
+    @Test
+    public void givenStringCell_whenGetCellStringValue_thenReturnStringValue() throws IOException {
+        Workbook workbook = new XSSFWorkbook(fileLocation);
+        Sheet sheet = workbook.getSheetAt(0);
+        Row row = sheet.getRow(0);
+
+        ExcelCellFormatter formatter = new ExcelCellFormatter();
+        assertEquals("String Test", formatter.getCellStringValue(row.getCell(STRING_CELL_INDEX)));
+        workbook.close();
+    }
+
+    @Test
+    public void givenBooleanCell_whenGetCellStringValue_thenReturnBooleanStringValue() throws IOException {
+        Workbook workbook = new XSSFWorkbook(fileLocation);
+        Sheet sheet = workbook.getSheetAt(0);
+        Row row = sheet.getRow(0);
+
+        ExcelCellFormatter formatter = new ExcelCellFormatter();
+        assertEquals("TRUE", formatter.getCellStringValue(row.getCell(BOOLEAN_CELL_INDEX)));
+        workbook.close();
+    }
+
+    @Test
+    public void givenNumericCell_whenGetCellStringValue_thenReturnNumericStringValue() throws IOException {
+        Workbook workbook = new XSSFWorkbook(fileLocation);
+        Sheet sheet = workbook.getSheetAt(0);
+        Row row = sheet.getRow(0);
+
+        ExcelCellFormatter formatter = new ExcelCellFormatter();
+        assertEquals("1.234", formatter.getCellStringValue(row.getCell(RAW_NUMERIC_CELL_INDEX)));
+        assertEquals("1.23", formatter.getCellStringValue(row.getCell(FORMATTED_NUMERIC_CELL_INDEX)));
+        workbook.close();
+    }
+
+    @Test
+    public void givenFormualCell_whenGetCellStringValue_thenReturnOriginalFormulaString() throws IOException {
+        Workbook workbook = new XSSFWorkbook(fileLocation);
+        Sheet sheet = workbook.getSheetAt(0);
+        Row row = sheet.getRow(0);
+
+        ExcelCellFormatter formatter = new ExcelCellFormatter();
+        assertEquals("SUM(1+2)", formatter.getCellStringValue(row.getCell(FORMULA_CELL_INDEX)));
+        workbook.close();
+    }
+
+    @Test
+    public void givenFormualCell_whenGetCellStringValueForFormula_thenReturnOriginalFormulatring() throws IOException {
+        Workbook workbook = new XSSFWorkbook(fileLocation);
+        Sheet sheet = workbook.getSheetAt(0);
+        Row row = sheet.getRow(0);
+
+        ExcelCellFormatter formatter = new ExcelCellFormatter();
+        assertEquals("3", formatter.getCellStringValueWithFormula(row.getCell(FORMULA_CELL_INDEX), workbook));
+        workbook.close();
+    }
+
+}

apache-poi/src/test/java/com/baeldung/poi/excel/read/cellvalueandnotformula/CellValueAndNotFormulaUnitTest.java

@@ -0,0 +1,39 @@
+package com.baeldung.poi.excel.read.cellvalueandnotformula;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.nio.file.Paths;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class CellValueAndNotFormulaUnitTest {
+
+    private CellValueAndNotFormulaHelper readCellValueAndNotFormulaHelper;
+    private String fileLocation;
+    private static final String FILE_NAME = "test.xlsx";
+
+    @Before
+    public void setup() throws URISyntaxException {
+        fileLocation = Paths.get(ClassLoader.getSystemResource(FILE_NAME).toURI()).toString();
+        readCellValueAndNotFormulaHelper = new CellValueAndNotFormulaHelper();
+    }
+
+    @Test
+    public void givenExcelCell_whenReadCellValueByLastCachedValue_thenProduceCorrectResult() throws IOException {
+        final double expectedResult = 7.0;
+        final Object cellValue = readCellValueAndNotFormulaHelper.getCellValueByFetchingLastCachedValue(fileLocation, "C2");
+
+        assertEquals(expectedResult, cellValue);
+    }
+
+    @Test
+    public void givenExcelCell_whenReadCellValueByEvaluatingFormula_thenProduceCorrectResult() throws IOException {
+        final double expectedResult = 7.0;
+        final Object cellValue = readCellValueAndNotFormulaHelper.getCellValueByEvaluatingFormula(fileLocation, "C2");
+
+        assertEquals(expectedResult, cellValue);
+    }
+}

apache-rocketmq/pom.xml

@@ -17,11 +17,12 @@
         <dependency>
             <groupId>org.apache.rocketmq</groupId>
             <artifactId>rocketmq-spring-boot-starter</artifactId>
-            <version>2.0.4</version>
+            <version>${rocketmq.version}</version>
         </dependency>
     </dependencies>
 
     <properties>
         <geode.core>1.6.0</geode.core>
+        <rocketmq.version>2.0.4</rocketmq.version>
     </properties>
 </project>

apache-tapestry/pom.xml

@@ -81,10 +81,10 @@ of testing facilities designed for use with TestNG (http://testng.org/), so it's
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>2.3.2</version>
+                <version>${compiler.plugin.version}</version>
                 <configuration>
-                    <source>1.8</source>
+                    <source>${source.version}</source>
-                    <target>1.8</target>
+                    <target>${target.version}</target>
                     <optimize>true</optimize>
                 </configuration>
             </plugin>
@@ -92,7 +92,7 @@ of testing facilities designed for use with TestNG (http://testng.org/), so it's
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
-                <version>2.7.2</version>
+                <version>${compiler.surefire.version}</version>
                 <configuration>
                     <systemPropertyVariables>
                         <tapestry.execution-mode>Qa</tapestry.execution-mode>
@@ -104,7 +104,7 @@ of testing facilities designed for use with TestNG (http://testng.org/), so it's
             <plugin>
                 <groupId>org.mortbay.jetty</groupId>
                 <artifactId>maven-jetty-plugin</artifactId>
-                <version>6.1.16</version>
+                <version>${compiler.jetty.version}</version>
                 <configuration>
                     <!-- Log to the console. -->
                     <requestLog implementation="org.mortbay.jetty.NCSARequestLog">
@@ -140,6 +140,11 @@ of testing facilities designed for use with TestNG (http://testng.org/), so it's
     </repositories>
 
     <properties>
+        <compiler.jetty.version>6.1.16</compiler.jetty.version>
+        <compiler.surefire.version>2.7.2</compiler.surefire.version>
+        <compiler.plugin.version>2.3.2</compiler.plugin.version>
+        <source.version>1.8</source.version>
+        <target.version>1.8</target.version>
         <tapestry-release-version>5.4.5</tapestry-release-version>
         <servlet-api-release-version>2.5</servlet-api-release-version>
         <testng-release-version>6.8.21</testng-release-version>

aws-reactive/pom.xml

@@ -17,6 +17,8 @@
 
 	<properties>
 		<java.version>1.8</java.version>
+        <spring.version>2.2.1.RELEASE</spring.version>
+        <awssdk.version>2.10.27</awssdk.version>
 	</properties>
 
 	<dependencyManagement>
@@ -26,7 +28,7 @@
 				<!-- Import dependency management from Spring Boot -->
 				<groupId>org.springframework.boot</groupId>
 				<artifactId>spring-boot-dependencies</artifactId>
-				<version>2.2.1.RELEASE</version>
+				<version>${spring.version}</version>
 				<type>pom</type>
 				<scope>import</scope>
 			</dependency>
@@ -34,7 +36,7 @@
 			<dependency>
 				<groupId>software.amazon.awssdk</groupId>
 				<artifactId>bom</artifactId>
-				<version>2.10.27</version>
+				<version>${awssdk.version}</version>
 				<type>pom</type>
 				<scope>import</scope>
 			</dependency>

blade/pom.xml

@@ -124,7 +124,7 @@
 
             <plugin>
                 <artifactId>maven-assembly-plugin</artifactId>
-                <version>3.1.0</version>
+                <version>${assembly.plugin.version}</version>
                 <configuration>
                     <finalName>${project.build.finalName}</finalName>
                     <appendAssemblyId>false</appendAssemblyId>
@@ -161,6 +161,7 @@
         <assertj-core.version>3.11.1</assertj-core.version>
         <maven-failsafe-plugin.version>3.0.0-M3</maven-failsafe-plugin.version>
         <process-exec-maven-plugin.version>0.7</process-exec-maven-plugin.version>
+        <assembly.plugin.version>3.1.0</assembly.plugin.version>
     </properties>
 
 </project>

cloud-foundry-uaa/pom.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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>
+    <artifactId>cloud-foundry-uaa</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>cloud-foundry-uaa</name>
+    <packaging>pom</packaging>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <modules>
+        <module>cf-uaa-oauth2-client</module>
+        <module>cf-uaa-oauth2-resource-server</module>
+    </modules>
+
+</project>

core-groovy-2/pom.xml

@@ -62,12 +62,12 @@
             <plugin>
                 <groupId>org.codehaus.groovy</groupId>
                 <artifactId>groovy-eclipse-compiler</artifactId>
-                <version>3.3.0-01</version>
+                <version>${groovy.compiler.version}</version>
                 <extensions>true</extensions>
             </plugin>
             <plugin>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.8.0</version>
+                <version>${compiler.plugin.version}</version>
                 <configuration>
                     <compilerId>groovy-eclipse-compiler</compilerId>
                     <source>${java.version}</source>
@@ -113,7 +113,7 @@
             </plugin>
             <plugin>
                 <artifactId>maven-surefire-plugin</artifactId>
-                <version>2.20.1</version>
+                <version>${surefire.plugin.version}</version>
                 <configuration>
                     <useFile>false</useFile>
                     <includes>
@@ -126,7 +126,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-assembly-plugin</artifactId>
-                <version>3.1.0</version>
+                <version>${assembly.plugin.version}</version>
                 <configuration>
                     <!-- get all project dependencies -->
                     <descriptorRefs>
@@ -183,6 +183,10 @@
         <groovy-wslite.version>1.1.3</groovy-wslite.version>
         <logback.version>1.2.3</logback.version>
         <groovy.version>2.5.7</groovy.version>
+        <assembly.plugin.version>3.1.0</assembly.plugin.version>
+        <surefire.plugin.version>2.20.1</surefire.plugin.version>
+        <compiler.plugin.version>3.8.0</compiler.plugin.version>
+        <groovy.compiler.version>3.3.0-01</groovy.compiler.version>
     </properties>
 
 </project>

core-groovy-2/src/test/groovy/com/baeldung/category/CategoryUnitTest.groovy

@@ -28,16 +28,17 @@ class CategoryUnitTest extends GroovyTestCase {
         }
     }
 
-    void test_whenUsingTimeCategory_thenOperationOnNumber() {
+//	http://team.baeldung.com/browse/BAEL-20687
-        SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy")
+//    void test_whenUsingTimeCategory_thenOperationOnNumber() {
-        use (TimeCategory) {
+//        SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy")
-            assert sdf.format(5.days.from.now) == sdf.format(new Date() + 5.days)
+//        use (TimeCategory) {
-
+//            assert sdf.format(5.days.from.now) == sdf.format(new Date() + 5.days)
-            sdf = new SimpleDateFormat("dd/MM/yyyy hh:mm:ss")
+//
-            assert sdf.format(10.minutes.from.now) == sdf.format(new Date() + 10.minutes)
+//            sdf = new SimpleDateFormat("dd/MM/yyyy hh:mm:ss")
-            assert sdf.format(2.hours.ago) == sdf.format(new Date() - 2.hours)
+//            assert sdf.format(10.minutes.from.now) == sdf.format(new Date() + 10.minutes)
-        }
+//            assert sdf.format(2.hours.ago) == sdf.format(new Date() - 2.hours)
-    }
+//        }
+//    }
 
     void test_whenUsingDOMCategory_thenOperationOnXML() {
 

core-groovy-2/src/test/groovy/com/baeldung/webservice/WebserviceUnitTest.groovy

@@ -9,7 +9,7 @@ import wslite.soap.SOAPMessageBuilder
 import wslite.http.auth.HTTPBasicAuthorization
 import org.junit.Test
 
-class WebserviceUnitTest extends GroovyTestCase {
+class WebserviceManualTest extends GroovyTestCase {
 
     JsonSlurper jsonSlurper = new JsonSlurper()
 
@@ -75,6 +75,7 @@ class WebserviceUnitTest extends GroovyTestCase {
         assert stories.size() == 5
     }
     
+    /* see BAEL-3753
     void test_whenConsumingSoap_thenReceiveResponse() {
         def url = "http://www.dataaccess.com/webservicesserver/numberconversion.wso"
         def soapClient = new SOAPClient(url)
@@ -89,6 +90,7 @@ class WebserviceUnitTest extends GroovyTestCase {
         def words = response.NumberToWordsResponse
         assert words == "one thousand two hundred and thirty four "
     }
+    */
 
     void test_whenConsumingRestGet_thenReceiveResponse() {
         def path = "/get"
@@ -149,4 +151,4 @@ class WebserviceUnitTest extends GroovyTestCase {
             assert e?.response?.statusCode != 200
         }
     }
-}
+}

core-groovy-collections/pom.xml

@@ -99,7 +99,7 @@
             </plugin>
             <plugin>
                 <artifactId>maven-surefire-plugin</artifactId>
-                <version>2.20.1</version>
+                <version>${surefire.plugin.version}</version>
                 <configuration>
                     <useFile>false</useFile>
                     <includes>
@@ -126,6 +126,7 @@
         <hsqldb.version>2.4.0</hsqldb.version>
         <spock-core.version>1.1-groovy-2.4</spock-core.version>
         <gmavenplus-plugin.version>1.6</gmavenplus-plugin.version>
+        <surefire.plugin.version>2.20.1</surefire.plugin.version>
     </properties>
 
 </project>

core-groovy/src/test/groovy/com/baeldung/file/ReadFileUnitTest.groovy

@@ -1,6 +1,7 @@
 package com.baeldung.file
 
 import spock.lang.Specification
+import spock.lang.Ignore
 
 class ReadFileUnitTest extends Specification {
 
@@ -32,6 +33,7 @@ class ReadFileUnitTest extends Specification {
             assert lines.size(), 3
     }
     
+    @Ignore
     def 'Should return file content in string using ReadFile.readFileString given filePath' () {
         given:
             def filePath = "src/main/resources/fileContent.txt"

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

@@ -42,12 +42,12 @@
         <dependency>
             <groupId>org.eclipse.collections</groupId>
             <artifactId>eclipse-collections</artifactId>
-            <version>10.0.0</version>
+            <version>${eclipse.collections.version}</version>
         </dependency>
         <dependency>
             <groupId>org.eclipse.collections</groupId>
             <artifactId>eclipse-collections-api</artifactId>
-            <version>10.0.0</version>
+            <version>${eclipse.collections.version}</version>
         </dependency>
     </dependencies>
 
@@ -108,6 +108,7 @@
         <assertj.version>3.11.1</assertj.version>
         <uberjar.name>benchmarks</uberjar.name>
         <jmh.version>1.22</jmh.version>
+        <eclipse.collections.version>10.0.0</eclipse.collections.version>
     </properties>
 
 </project>

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

@@ -41,7 +41,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
-                <version>3.0.0-M3</version>
+                <version>${surefire.plugin.version}</version>
                 <configuration>
                     <argLine>--enable-preview</argLine>
                 </configuration>
@@ -53,6 +53,7 @@
         <maven.compiler.source.version>13</maven.compiler.source.version>
         <maven.compiler.target.version>13</maven.compiler.target.version>
         <assertj.version>3.6.1</assertj.version>
+        <surefire.plugin.version>3.0.0-M3</surefire.plugin.version>
     </properties>
 
 </project>

core-java-modules/core-java-13/src/test/java/com/baeldung/newfeatures/SwitchExpressionsWithYieldUnitTest.java

@@ -0,0 +1,27 @@
+package com.baeldung.newfeatures;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class SwitchExpressionsWithYieldUnitTest {
+
+    @Test
+    @SuppressWarnings("preview")
+    public void whenSwitchingOnOperationSquareMe_thenWillReturnSquare() {
+        var me = 4;
+        var operation = "squareMe";
+        var result = switch (operation) {
+        case "doubleMe" -> {
+            yield me * 2;
+        }
+        case "squareMe" -> {
+            yield me * me;
+        }
+        default -> me;
+        };
+
+        assertEquals(16, result);
+    }
+
+}

core-java-modules/core-java-13/src/test/java/com/baeldung/newfeatures/TextBlocksUnitTest.java

@@ -0,0 +1,39 @@
+package com.baeldung.newfeatures;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+public class TextBlocksUnitTest {
+
+    private static final String JSON_STRING = "{\r\n" + "\"name\" : \"Baeldung\",\r\n" + "\"website\" : \"https://www.%s.com/\"\r\n" + "}";
+
+    @SuppressWarnings("preview")
+    private static final String TEXT_BLOCK_JSON = """
+            {
+            "name" : "Baeldung",
+            "website" : "https://www.%s.com/"
+            }
+        """;
+
+    @Test
+    public void whenTextBlocks_thenStringOperationsWork() {
+
+        assertThat(TEXT_BLOCK_JSON.contains("Baeldung")).isTrue();
+        assertThat(TEXT_BLOCK_JSON.indexOf("www")).isGreaterThan(0);
+        assertThat(TEXT_BLOCK_JSON.length()).isGreaterThan(0);
+
+    }
+
+    @SuppressWarnings("removal")
+    @Test
+    public void whenTextBlocks_thenFormattedWorksAsFormat() {
+        assertThat(TEXT_BLOCK_JSON.formatted("baeldung")
+            .contains("www.baeldung.com")).isTrue();
+
+        assertThat(String.format(JSON_STRING, "baeldung")
+            .contains("www.baeldung.com")).isTrue();
+
+    }
+   
+}

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

@@ -36,7 +36,7 @@
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-surefire-plugin</artifactId>
-				<version>3.0.0-M3</version>
+				<version>${surefire.plugin.version}</version>
 				<configuration>
 					<argLine>--enable-preview</argLine>
 				</configuration>
@@ -47,6 +47,7 @@
 	<properties>
 		<maven.compiler.source.version>14</maven.compiler.source.version>
 		<maven.compiler.target.version>14</maven.compiler.target.version>
+        <surefire.plugin.version>3.0.0-M3</surefire.plugin.version>
 	</properties>
 
 </project>

core-java-modules/core-java-arrays-2/pom.xml

@@ -51,7 +51,7 @@
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-shade-plugin</artifactId>
-				<version>3.2.0</version>
+				<version>${shade.plugin.version}</version>
 				<executions>
 					<execution>
 						<phase>package</phase>
@@ -79,6 +79,7 @@
         <commons-lang3.version>3.9</commons-lang3.version>
         <!-- testing -->
         <assertj-core.version>3.10.0</assertj-core.version>
+        <shade.plugin.version>3.2.0</shade.plugin.version>
     </properties>
 
 </project>

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

@@ -183,8 +183,8 @@
                 <artifactId>maven-javadoc-plugin</artifactId>
                 <version>${maven-javadoc-plugin.version}</version>
                 <configuration>
-                    <source>1.8</source>
+                    <source>${source.version}</source>
-                    <target>1.8</target>
+                    <target>${target.version}</target>
                 </configuration>
             </plugin>
         </plugins>
@@ -373,6 +373,8 @@
         <maven-shade-plugin.version>3.1.1</maven-shade-plugin.version>
         <spring-boot-maven-plugin.version>2.0.3.RELEASE</spring-boot-maven-plugin.version>
         <exec-maven-plugin.version>1.6.0</exec-maven-plugin.version>
+        <source.version>1.8</source.version>
+        <target.version>1.8</target.version>
     </properties>
 
 </project>

core-java-modules/core-java-concurrency-advanced-3/src/main/java/com/baeldung/async/EAAsyncExample.java

@@ -0,0 +1,57 @@
+package com.baeldung.async;
+
+import static com.ea.async.Async.await;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+
+import com.ea.async.Async;
+
+public class EAAsyncExample {
+
+    static {
+        Async.init();
+    }
+
+    public static void main(String[] args) throws Exception {
+        usingCompletableFuture();
+        usingAsyncAwait();
+    }
+
+    public static void usingCompletableFuture() throws InterruptedException, ExecutionException, Exception {
+        CompletableFuture<Void> completableFuture = hello()
+            .thenComposeAsync(hello -> mergeWorld(hello))
+            .thenAcceptAsync(helloWorld -> print(helloWorld))
+            .exceptionally( throwable -> {
+                System.out.println(throwable.getCause()); 
+                return null;
+            });
+        completableFuture.get();
+    }
+
+    public static CompletableFuture<String> hello() {
+        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "Hello");
+        return completableFuture;
+    }
+
+    public static CompletableFuture<String> mergeWorld(String s) {
+        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
+            return s + " World!";
+        });
+        return completableFuture;
+    }
+
+    public static void print(String str) {
+        CompletableFuture.runAsync(() -> System.out.println(str));
+    }
+
+    private static void usingAsyncAwait() {
+        try {
+            String hello = await(hello());
+            String helloWorld = await(mergeWorld(hello));
+            await(CompletableFuture.runAsync(() -> print(helloWorld)));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}

core-java-modules/core-java-concurrency-advanced-3/src/main/java/com/baeldung/async/JavaAsync.java

@@ -0,0 +1,183 @@
+package com.baeldung.async;
+
+import static com.ea.async.Async.await;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+import com.google.common.util.concurrent.AsyncCallable;
+import com.google.common.util.concurrent.Callables;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.jcabi.aspects.Async;
+import com.jcabi.aspects.Loggable;
+
+public class JavaAsync {
+
+    static {
+        com.ea.async.Async.init();
+    }
+
+    private static final ExecutorService threadpool = Executors.newCachedThreadPool();
+
+    public static void main (String[] args) throws InterruptedException, ExecutionException {
+        int number = 20;
+
+        //Thread Example
+        factorialUsingThread(number).start();
+
+        //FutureTask Example
+        Future<Long> futureTask = factorialUsingFutureTask(number);
+        System.out.println("Factorial of " + number + " is: " + futureTask.get());
+
+        // CompletableFuture Example
+        Future<Long> completableFuture = factorialUsingCompletableFuture(number);
+        System.out.println("Factorial of " + number + " is: " + completableFuture.get());
+
+        // EA Async example
+        System.out.println("Factorial of " + number + " is: " + factorialUsingEAAsync(number));
+
+        // cactoos async example
+        Future<Long> asyncFuture = factorialUsingCactoos(number);
+        System.out.println("Factorial of " + number + " is: " + asyncFuture.get());
+
+        // Guava example
+        ListenableFuture<Long> guavaFuture = factorialUsingGuavaServiceSubmit(number);
+        System.out.println("Factorial of " + number + " is: " + guavaFuture.get());
+
+        ListenableFuture<Long> guavaFutures = factorialUsingGuavaFutures(number);
+        System.out.println("Factorial of " + number + " is: " + guavaFutures.get());
+
+        // @async jcabi-aspect example
+        Future<Long> aspectFuture = factorialUsingJcabiAspect(number);
+        System.out.println("Factorial of " + number + " is: " + aspectFuture.get());
+
+    }
+
+    /**
+     * Finds factorial of a number
+     * @param number
+     * @return
+     */
+    public static long factorial(int number) {
+        long result = 1; 
+        for(int i=number;i>0;i--) {
+            result *= i; 
+        } 
+        return result; 
+    }
+
+    /**
+     * Finds factorial of a number using Thread
+     * @param number
+     * @return
+     */
+    @Loggable
+    public static Thread factorialUsingThread(int number) {
+        Thread newThread = new Thread(() -> {
+            System.out.println("Factorial of " + number + " is: " + factorial(number));
+        });
+
+        return newThread;
+    }
+
+    /**
+     * Finds factorial of a number using FutureTask
+     * @param number
+     * @return
+     */
+    @Loggable
+    public static Future<Long> factorialUsingFutureTask(int number) {
+        Future<Long> futureTask = threadpool.submit(() -> factorial(number)); 
+
+        while (!futureTask.isDone()) { 
+            System.out.println("FutureTask is not finished yet..."); 
+        } 
+
+        return futureTask;
+    }
+
+    /**
+     * Finds factorial of a number using CompletableFuture
+     * @param number
+     * @return
+     */
+    @Loggable
+    public static Future<Long> factorialUsingCompletableFuture(int number) {
+        CompletableFuture<Long> completableFuture = CompletableFuture.supplyAsync(() -> factorial(number));
+        return completableFuture;
+    }
+
+    /**
+     * Finds factorial of a number using EA Async
+     * @param number
+     * @return
+     */
+    @Loggable
+    public static long factorialUsingEAAsync(int number) {
+        CompletableFuture<Long> completableFuture = CompletableFuture.supplyAsync(() -> factorial(number));
+        long result = await(completableFuture);
+        return result;
+    }
+
+    /**
+     * Finds factorial of a number using Async of Cactoos
+     * @param number
+     * @return
+     * @throws InterruptedException
+     * @throws ExecutionException
+     */
+    @Loggable
+    public static Future<Long> factorialUsingCactoos(int number) throws InterruptedException, ExecutionException {
+        org.cactoos.func.Async<Integer, Long> asyncFunction = new org.cactoos.func.Async<Integer, Long>(input -> factorial(input));
+        Future<Long> asyncFuture = asyncFunction.apply(number);
+        return asyncFuture;
+    }
+
+    /**
+     * Finds factorial of a number using Guava's ListeningExecutorService.submit()
+     * @param number
+     * @return
+     */
+    @Loggable
+    public static ListenableFuture<Long> factorialUsingGuavaServiceSubmit(int number) {
+        ListeningExecutorService service = MoreExecutors.listeningDecorator(threadpool);
+        ListenableFuture<Long> factorialFuture = (ListenableFuture<Long>) service.submit(()-> factorial(number));
+        return factorialFuture;
+    }
+
+    /**
+     * Finds factorial of a number using Guava's Futures.submitAsync()
+     * @param number
+     * @return
+     */
+    @Loggable
+    public static ListenableFuture<Long> factorialUsingGuavaFutures(int number) {
+        ListeningExecutorService service = MoreExecutors.listeningDecorator(threadpool);
+        AsyncCallable<Long> asyncCallable = Callables.asAsyncCallable(new Callable<Long>() {
+            public Long call() {
+                return factorial(number);
+            }
+        }, service);
+        return Futures.submitAsync(asyncCallable, service);
+    }
+
+    /**
+     * Finds factorial of a number using @Async of jcabi-aspects
+     * @param number
+     * @return
+     */
+    @Async
+    @Loggable
+    public static Future<Long> factorialUsingJcabiAspect(int number) {
+        Future<Long> factorialFuture = CompletableFuture.supplyAsync(() -> factorial(number));
+        return factorialFuture;
+    }
+
+}

core-java-modules/core-java-concurrency-advanced-3/src/test/java/com/baeldung/rejection/SaturationPolicyUnitTest.java

@@ -1,6 +1,7 @@
 package com.baeldung.rejection;
 
 import org.junit.After;
+import org.junit.Ignore;
 import org.junit.Test;
 
 import java.util.ArrayList;
@@ -28,6 +29,7 @@ public class SaturationPolicyUnitTest {
         }
     }
 
+    @Ignore
     @Test
     public void givenAbortPolicy_WhenSaturated_ThenShouldThrowRejectedExecutionException() {
         executor = new ThreadPoolExecutor(1, 1, 0, MILLISECONDS, new SynchronousQueue<>(), new AbortPolicy());
@@ -36,6 +38,7 @@ public class SaturationPolicyUnitTest {
         assertThatThrownBy(() -> executor.execute(() -> System.out.println("Will be rejected"))).isInstanceOf(RejectedExecutionException.class);
     }
 
+    @Ignore
     @Test
     public void givenCallerRunsPolicy_WhenSaturated_ThenTheCallerThreadRunsTheTask() {
         executor = new ThreadPoolExecutor(1, 1, 0, MILLISECONDS, new SynchronousQueue<>(), new CallerRunsPolicy());

core-java-modules/core-java-date-operations-1/README.md

@@ -1,6 +1,5 @@
-## Java Date/time computations Cookbooks and Examples
+## Core Date Operations (Part 1)
-
+This module contains articles about date operations in Java.
-This module contains articles about date and time computations in Java.
 
 ### Relevant Articles: 
 - [Difference Between Two Dates in Java](http://www.baeldung.com/java-date-difference)
@@ -13,3 +12,4 @@ This module contains articles about date and time computations in Java.
 - [Increment Date in Java](http://www.baeldung.com/java-increment-date)
 - [Add Hours To a Date In Java](http://www.baeldung.com/java-add-hours-date)
 - [Introduction to Joda-Time](http://www.baeldung.com/joda-time)
+- [[Next -->]](/core-java-modules/core-java-date-operations-2)

core-java-modules/core-java-date-operations-1/pom.xml

@@ -2,9 +2,9 @@
 <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>
-    <artifactId>core-java-datetime-computations</artifactId>
+    <artifactId>core-java-date-operations-1</artifactId>
     <version>${project.parent.version}</version>
-    <name>core-java-datetime-computations</name>
+    <name>core-java-date-operations-1</name>
     <packaging>jar</packaging>
 
     <parent>
@@ -41,7 +41,7 @@
     </dependencies>
 
     <build>
-        <finalName>core-java-datetime-computations</finalName>
+        <finalName>core-java-date-operations-1</finalName>
         <resources>
             <resource>
                 <directory>src/main/resources</directory>

core-java-modules/core-java-date-operations-2/README.md

@@ -1,4 +1,4 @@
-## Core Date Operations
+## Core Date Operations (Part 2)
 This module contains articles about date operations in Java.
 
 ### Relevant Articles:
@@ -6,3 +6,4 @@ This module contains articles about date operations in Java.
 - [Skipping Weekends While Adding Days to LocalDate in Java 8](https://www.baeldung.com/java-localdate-add-days-skip-weekends)
 - [Checking If Two Java Dates Are on the Same Day](https://www.baeldung.com/java-check-two-dates-on-same-day)
 - [Converting Java Date to OffsetDateTime](https://www.baeldung.com/java-convert-date-to-offsetdatetime)
+- [[<-- Prev]](/core-java-modules/core-java-date-operations-1)

core-java-modules/core-java-date-operations-2/pom.xml

@@ -3,9 +3,9 @@
     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>
-    <artifactId>core-java-date-operations</artifactId>
+    <artifactId>core-java-date-operations-2</artifactId>
     <version>${project.parent.version}</version>
-    <name>core-java-date-operations</name>
+    <name>core-java-date-operations-2</name>
     <packaging>jar</packaging>
 
     <parent>
@@ -31,11 +31,18 @@
             <artifactId>hirondelle-date4j</artifactId>
             <version>${hirondelle-date4j.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <properties>
         <joda-time.version>2.10</joda-time.version>
         <hirondelle-date4j.version>1.5.1</hirondelle-date4j.version>
+        <assertj.version>3.14.0</assertj.version>
     </properties>
 
 </project>

core-java-modules/core-java-date-operations-2/src/main/java/com/baeldung/date/comparison/DateComparisonUtils.java

@@ -1,65 +1,65 @@
-package com.baeldung.date.comparison;
+package com.baeldung.date.comparison;
-
+
-import java.text.SimpleDateFormat;
+import java.text.SimpleDateFormat;
-import java.time.Instant;
+import java.time.Instant;
-import java.time.LocalDate;
+import java.time.LocalDate;
-import java.time.ZoneId;
+import java.time.ZoneId;
-import java.time.temporal.ChronoUnit;
+import java.time.temporal.ChronoUnit;
-import java.util.Calendar;
+import java.util.Calendar;
-import java.util.Date;
+import java.util.Date;
-import java.util.TimeZone;
+import java.util.TimeZone;
-
+
-import org.apache.commons.lang3.time.DateUtils;
+import org.apache.commons.lang3.time.DateUtils;
-
+
-import hirondelle.date4j.DateTime;
+import hirondelle.date4j.DateTime;
-
+
-public class DateComparisonUtils {
+public class DateComparisonUtils {
-
+
-    public static boolean isSameDayUsingLocalDate(Date date1, Date date2) {
+    public static boolean isSameDayUsingLocalDate(Date date1, Date date2) {
-        LocalDate localDate1 = date1.toInstant()
+        LocalDate localDate1 = date1.toInstant()
-            .atZone(ZoneId.systemDefault())
+            .atZone(ZoneId.systemDefault())
-            .toLocalDate();
+            .toLocalDate();
-        LocalDate localDate2 = date2.toInstant()
+        LocalDate localDate2 = date2.toInstant()
-            .atZone(ZoneId.systemDefault())
+            .atZone(ZoneId.systemDefault())
-            .toLocalDate();
+            .toLocalDate();
-        return localDate1.isEqual(localDate2);
+        return localDate1.isEqual(localDate2);
-    }
+    }
-
+
-    public static boolean isSameDayUsingInstant(Date date1, Date date2) {
+    public static boolean isSameDayUsingInstant(Date date1, Date date2) {
-        Instant instant1 = date1.toInstant()
+        Instant instant1 = date1.toInstant()
-            .truncatedTo(ChronoUnit.DAYS);
+            .truncatedTo(ChronoUnit.DAYS);
-        Instant instant2 = date2.toInstant()
+        Instant instant2 = date2.toInstant()
-            .truncatedTo(ChronoUnit.DAYS);
+            .truncatedTo(ChronoUnit.DAYS);
-        return instant1.equals(instant2);
+        return instant1.equals(instant2);
-    }
+    }
-
+
-    public static boolean isSameDayUsingSimpleDateFormat(Date date1, Date date2) {
+    public static boolean isSameDayUsingSimpleDateFormat(Date date1, Date date2) {
-        SimpleDateFormat fmt = new SimpleDateFormat("yyyyMMdd");
+        SimpleDateFormat fmt = new SimpleDateFormat("yyyyMMdd");
-        return fmt.format(date1)
+        return fmt.format(date1)
-            .equals(fmt.format(date2));
+            .equals(fmt.format(date2));
-    }
+    }
-
+
-    public static boolean isSameDayUsingCalendar(Date date1, Date date2) {
+    public static boolean isSameDayUsingCalendar(Date date1, Date date2) {
-        Calendar calendar1 = Calendar.getInstance();
+        Calendar calendar1 = Calendar.getInstance();
-        calendar1.setTime(date1);
+        calendar1.setTime(date1);
-        Calendar calendar2 = Calendar.getInstance();
+        Calendar calendar2 = Calendar.getInstance();
-        calendar2.setTime(date2);
+        calendar2.setTime(date2);
-        return calendar1.get(Calendar.YEAR) == calendar2.get(Calendar.YEAR) && calendar1.get(Calendar.MONTH) == calendar2.get(Calendar.MONTH) && calendar1.get(Calendar.DAY_OF_MONTH) == calendar2.get(Calendar.DAY_OF_MONTH);
+        return calendar1.get(Calendar.YEAR) == calendar2.get(Calendar.YEAR) && calendar1.get(Calendar.MONTH) == calendar2.get(Calendar.MONTH) && calendar1.get(Calendar.DAY_OF_MONTH) == calendar2.get(Calendar.DAY_OF_MONTH);
-    }
+    }
-
+
-    public static boolean isSameDayUsingApacheCommons(Date date1, Date date2) {
+    public static boolean isSameDayUsingApacheCommons(Date date1, Date date2) {
-        return DateUtils.isSameDay(date1, date2);
+        return DateUtils.isSameDay(date1, date2);
-    }
+    }
-
+
-    public static boolean isSameDayUsingJoda(Date date1, Date date2) {
+    public static boolean isSameDayUsingJoda(Date date1, Date date2) {
-        org.joda.time.LocalDate localDate1 = new org.joda.time.LocalDate(date1);
+        org.joda.time.LocalDate localDate1 = new org.joda.time.LocalDate(date1);
-        org.joda.time.LocalDate localDate2 = new org.joda.time.LocalDate(date2);
+        org.joda.time.LocalDate localDate2 = new org.joda.time.LocalDate(date2);
-        return localDate1.equals(localDate2);
+        return localDate1.equals(localDate2);
-    }
+    }
-
+
-    public static boolean isSameDayUsingDate4j(Date date1, Date date2) {
+    public static boolean isSameDayUsingDate4j(Date date1, Date date2) {
-        DateTime dateObject1 = DateTime.forInstant(date1.getTime(), TimeZone.getDefault());
+        DateTime dateObject1 = DateTime.forInstant(date1.getTime(), TimeZone.getDefault());
-        DateTime dateObject2 = DateTime.forInstant(date2.getTime(), TimeZone.getDefault());
+        DateTime dateObject2 = DateTime.forInstant(date2.getTime(), TimeZone.getDefault());
-        return dateObject1.isSameDayAs(dateObject2);
+        return dateObject1.isSameDayAs(dateObject2);
-    }
+    }
-}
+}

core-java-modules/core-java-date-operations-2/src/main/java/com/baeldung/timer/DatabaseMigrationTask.java

@@ -0,0 +1,19 @@
+package com.baeldung.timer;
+
+import java.util.List;
+import java.util.TimerTask;
+
+public class DatabaseMigrationTask extends TimerTask {
+    private List<String> oldDatabase;
+    private List<String> newDatabase;
+
+    public DatabaseMigrationTask(List<String> oldDatabase, List<String> newDatabase) {
+        this.oldDatabase = oldDatabase;
+        this.newDatabase = newDatabase;
+    }
+
+    @Override
+    public void run() {
+        newDatabase.addAll(oldDatabase);
+    }
+}

core-java-modules/core-java-date-operations-2/src/main/java/com/baeldung/timer/NewsletterTask.java

@@ -0,0 +1,14 @@
+package com.baeldung.timer;
+
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.TimerTask;
+
+public class NewsletterTask extends TimerTask {
+    @Override
+    public void run() {
+        System.out.println("Email sent at: "
+          + LocalDateTime.ofInstant(Instant.ofEpochMilli(scheduledExecutionTime()), ZoneId.systemDefault()));
+    }
+}

core-java-modules/core-java-date-operations-2/src/test/java/com/baeldung/date/comparison/DateComparisonUtilsUnitTest.java

@@ -1,57 +1,57 @@
-package com.baeldung.date.comparison;
+package com.baeldung.date.comparison;
-
+
-import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertTrue;
-
+
-import java.time.LocalDateTime;
+import java.time.LocalDateTime;
-import java.time.ZoneId;
+import java.time.ZoneId;
-import java.util.Date;
+import java.util.Date;
-
+
-import org.junit.Test;
+import org.junit.Test;
-
+
-public class DateComparisonUtilsUnitTest {
+public class DateComparisonUtilsUnitTest {
-
+
-    private Date day1Morning = toDate(LocalDateTime.of(2019, 10, 19, 6, 30, 40));
+    private Date day1Morning = toDate(LocalDateTime.of(2019, 10, 19, 6, 30, 40));
-    private Date day1Evening = toDate(LocalDateTime.of(2019, 10, 19, 18, 30, 50));
+    private Date day1Evening = toDate(LocalDateTime.of(2019, 10, 19, 18, 30, 50));
-    private Date day2Morning = toDate(LocalDateTime.of(2019, 10, 20, 6, 30, 50));
+    private Date day2Morning = toDate(LocalDateTime.of(2019, 10, 20, 6, 30, 50));
-
+
-    private Date toDate(LocalDateTime localDateTime) {
+    private Date toDate(LocalDateTime localDateTime) {
-        return Date.from(localDateTime.atZone(ZoneId.systemDefault())
+        return Date.from(localDateTime.atZone(ZoneId.systemDefault())
-            .toInstant());
+            .toInstant());
-    }
+    }
-
+
-    @Test
+    @Test
-    public void givenDatesWithDifferentTime_whenIsSameDay_thenReturnsTrue() {
+    public void givenDatesWithDifferentTime_whenIsSameDay_thenReturnsTrue() {
-        assertTrue(DateComparisonUtils.isSameDayUsingLocalDate(day1Morning, day1Evening));
+        assertTrue(DateComparisonUtils.isSameDayUsingLocalDate(day1Morning, day1Evening));
-        assertTrue(DateComparisonUtils.isSameDayUsingInstant(day1Morning, day1Evening));
+        assertTrue(DateComparisonUtils.isSameDayUsingInstant(day1Morning, day1Evening));
-        assertTrue(DateComparisonUtils.isSameDayUsingSimpleDateFormat(day1Morning, day1Evening));
+        assertTrue(DateComparisonUtils.isSameDayUsingSimpleDateFormat(day1Morning, day1Evening));
-        assertTrue(DateComparisonUtils.isSameDayUsingCalendar(day1Morning, day1Evening));
+        assertTrue(DateComparisonUtils.isSameDayUsingCalendar(day1Morning, day1Evening));
-        assertTrue(DateComparisonUtils.isSameDayUsingApacheCommons(day1Morning, day1Evening));
+        assertTrue(DateComparisonUtils.isSameDayUsingApacheCommons(day1Morning, day1Evening));
-        assertTrue(DateComparisonUtils.isSameDayUsingJoda(day1Morning, day1Evening));
+        assertTrue(DateComparisonUtils.isSameDayUsingJoda(day1Morning, day1Evening));
-        assertTrue(DateComparisonUtils.isSameDayUsingDate4j(day1Morning, day1Evening));
+        assertTrue(DateComparisonUtils.isSameDayUsingDate4j(day1Morning, day1Evening));
-    }
+    }
-
+
-    @Test
+    @Test
-    public void givenDates_whenIsDifferentDay_thenReturnsFalse() {
+    public void givenDates_whenIsDifferentDay_thenReturnsFalse() {
-        assertFalse(DateComparisonUtils.isSameDayUsingLocalDate(day1Morning, day2Morning));
+        assertFalse(DateComparisonUtils.isSameDayUsingLocalDate(day1Morning, day2Morning));
-        assertFalse(DateComparisonUtils.isSameDayUsingLocalDate(day1Evening, day2Morning));
+        assertFalse(DateComparisonUtils.isSameDayUsingLocalDate(day1Evening, day2Morning));
-
+
-        assertFalse(DateComparisonUtils.isSameDayUsingInstant(day1Morning, day2Morning));
+        assertFalse(DateComparisonUtils.isSameDayUsingInstant(day1Morning, day2Morning));
-        assertFalse(DateComparisonUtils.isSameDayUsingInstant(day1Evening, day2Morning));
+        assertFalse(DateComparisonUtils.isSameDayUsingInstant(day1Evening, day2Morning));
-
+
-        assertFalse(DateComparisonUtils.isSameDayUsingSimpleDateFormat(day1Morning, day2Morning));
+        assertFalse(DateComparisonUtils.isSameDayUsingSimpleDateFormat(day1Morning, day2Morning));
-        assertFalse(DateComparisonUtils.isSameDayUsingSimpleDateFormat(day1Evening, day2Morning));
+        assertFalse(DateComparisonUtils.isSameDayUsingSimpleDateFormat(day1Evening, day2Morning));
-
+
-        assertFalse(DateComparisonUtils.isSameDayUsingCalendar(day1Morning, day2Morning));
+        assertFalse(DateComparisonUtils.isSameDayUsingCalendar(day1Morning, day2Morning));
-        assertFalse(DateComparisonUtils.isSameDayUsingCalendar(day1Evening, day2Morning));
+        assertFalse(DateComparisonUtils.isSameDayUsingCalendar(day1Evening, day2Morning));
-
+
-        assertFalse(DateComparisonUtils.isSameDayUsingApacheCommons(day1Morning, day2Morning));
+        assertFalse(DateComparisonUtils.isSameDayUsingApacheCommons(day1Morning, day2Morning));
-        assertFalse(DateComparisonUtils.isSameDayUsingApacheCommons(day1Evening, day2Morning));
+        assertFalse(DateComparisonUtils.isSameDayUsingApacheCommons(day1Evening, day2Morning));
-
+
-        assertFalse(DateComparisonUtils.isSameDayUsingJoda(day1Morning, day2Morning));
+        assertFalse(DateComparisonUtils.isSameDayUsingJoda(day1Morning, day2Morning));
-        assertFalse(DateComparisonUtils.isSameDayUsingJoda(day1Evening, day2Morning));
+        assertFalse(DateComparisonUtils.isSameDayUsingJoda(day1Evening, day2Morning));
-
+
-        assertFalse(DateComparisonUtils.isSameDayUsingDate4j(day1Morning, day2Morning));
+        assertFalse(DateComparisonUtils.isSameDayUsingDate4j(day1Morning, day2Morning));
-        assertFalse(DateComparisonUtils.isSameDayUsingDate4j(day1Evening, day2Morning));
+        assertFalse(DateComparisonUtils.isSameDayUsingDate4j(day1Evening, day2Morning));
-    }
+    }
-}
+}

core-java-modules/core-java-date-operations-2/src/test/java/com/baeldung/timer/DatabaseMigrationTaskUnitTest.java

@@ -0,0 +1,44 @@
+package com.baeldung.timer;
+
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.*;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class DatabaseMigrationTaskUnitTest {
+    @Test
+    void givenDatabaseMigrationTask_whenTimerScheduledForNowPlusTwoSeconds_thenDataMigratedAfterTwoSeconds() throws Exception {
+        List<String> oldDatabase = Arrays.asList("Harrison Ford", "Carrie Fisher", "Mark Hamill");
+        List<String> newDatabase = new ArrayList<>();
+
+        LocalDateTime twoSecondsLater = LocalDateTime.now().plusSeconds(2);
+        Date twoSecondsLaterAsDate = Date.from(twoSecondsLater.atZone(ZoneId.systemDefault()).toInstant());
+
+        new Timer().schedule(new DatabaseMigrationTask(oldDatabase, newDatabase), twoSecondsLaterAsDate);
+
+        while (LocalDateTime.now().isBefore(twoSecondsLater)) {
+            assertThat(newDatabase).isEmpty();
+            Thread.sleep(500);
+        }
+        assertThat(newDatabase).containsExactlyElementsOf(oldDatabase);
+    }
+
+    @Test
+    void givenDatabaseMigrationTask_whenTimerScheduledInTwoSeconds_thenDataMigratedAfterTwoSeconds() throws Exception {
+        List<String> oldDatabase = Arrays.asList("Harrison Ford", "Carrie Fisher", "Mark Hamill");
+        List<String> newDatabase = new ArrayList<>();
+
+        new Timer().schedule(new DatabaseMigrationTask(oldDatabase, newDatabase), 2000);
+
+        LocalDateTime twoSecondsLater = LocalDateTime.now().plusSeconds(2);
+
+        while (LocalDateTime.now().isBefore(twoSecondsLater)) {
+            assertThat(newDatabase).isEmpty();
+            Thread.sleep(500);
+        }
+        assertThat(newDatabase).containsExactlyElementsOf(oldDatabase);
+    }
+}

core-java-modules/core-java-date-operations-2/src/test/java/com/baeldung/timer/NewsletterTaskUnitTest.java

@@ -0,0 +1,33 @@
+package com.baeldung.timer;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Timer;
+
+class NewsletterTaskUnitTest {
+    private final Timer timer = new Timer();
+
+    @AfterEach
+    void afterEach() {
+        timer.cancel();
+    }
+
+    @Test
+    void givenNewsletterTask_whenTimerScheduledEachSecondFixedDelay_thenNewsletterSentEachSecond() throws Exception {
+        timer.schedule(new NewsletterTask(), 0, 1000);
+
+        for (int i = 0; i < 3; i++) {
+            Thread.sleep(1000);
+        }
+    }
+
+    @Test
+    void givenNewsletterTask_whenTimerScheduledEachSecondFixedRate_thenNewsletterSentEachSecond() throws Exception {
+        timer.scheduleAtFixedRate(new NewsletterTask(), 0, 1000);
+
+        for (int i = 0; i < 3; i++) {
+            Thread.sleep(1000);
+        }
+    }
+}

core-java-modules/core-java-datetime-java8-2/pom.xml

@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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>
+    <artifactId>core-java-datetime-java8</artifactId>
+    <version>${project.parent.version}</version>
+    <name>core-java-datetime-java8</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-java</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../../parent-java</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>joda-time</groupId>
+            <artifactId>joda-time</artifactId>
+            <version>${joda-time.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>log4j</groupId>
+            <artifactId>log4j</artifactId>
+            <version>${log4j.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>core-java-datetime-java8</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${maven.compiler.source}</source>
+                    <target>${maven.compiler.target}</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <maven.compiler.source>1.9</maven.compiler.source>
+        <maven.compiler.target>1.9</maven.compiler.target>
+        <joda-time.version>2.10</joda-time.version>
+        <!-- testing -->
+        <assertj.version>3.6.1</assertj.version>
+    </properties>
+
+</project>

core-java-modules/core-java-datetime-java8-2/src/main/java/com/baeldung/localdate/LocalDateExample.java

@@ -0,0 +1,31 @@
+package com.baeldung.localdate;
+
+import java.time.LocalDate;
+import java.time.Month;
+import java.time.format.DateTimeFormatter;
+
+public class LocalDateExample {
+    public LocalDate getCustomDateOne(int year, int month, int dayOfMonth) {
+        return LocalDate.of(year, month, dayOfMonth);
+    }
+
+    public LocalDate getCustomDateTwo(int year, Month month, int dayOfMonth) {
+        return LocalDate.of(year, month, dayOfMonth);
+    }
+
+    public LocalDate getDateFromEpochDay(long epochDay) {
+        return LocalDate.ofEpochDay(epochDay);
+    }
+
+    public LocalDate getDateFromYearAndDayOfYear(int year, int dayOfYear) {
+        return LocalDate.ofYearDay(year, dayOfYear);
+    }
+
+    public LocalDate getDateFromString(String date) {
+        return LocalDate.parse(date);
+    }
+
+    public LocalDate getDateFromStringAndFormatter(String date, String pattern) {
+        return LocalDate.parse(date, DateTimeFormatter.ofPattern(pattern));
+    }
+}

core-java-modules/core-java-datetime-java8-2/src/test/java/com/baeldung/localdate/LocalDateExampleUnitTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.localdate;
+
+import static org.junit.Assert.assertEquals;
+
+import java.time.Month;
+
+import org.junit.Test;
+
+public class LocalDateExampleUnitTest {
+    private LocalDateExample date = new LocalDateExample();
+
+    @Test
+    public void givenValues_whenUsingOfMethod_thenLocalDate() {
+        assertEquals("2020-01-08", date.getCustomDateOne(2020, 1, 8));
+    }
+
+    @Test
+    public void givenValuesWithMonthEnum_whenUsingOfMethod_thenLocalDate() {
+        assertEquals("2020-01-08", date.getCustomDateTwo(2020, Month.JANUARY, 8));
+    }
+
+    @Test
+    public void givenValues_whenUsingEpochDay_thenLocalDate() {
+        assertEquals("2020-01-08", date.getDateFromEpochDay(18269));
+    }
+
+    @Test
+    public void givenValues_whenUsingYearDay_thenLocalDate() {
+        assertEquals("2020-01-08", date.getDateFromYearAndDayOfYear(2020, 8));
+    }
+
+    @Test
+    public void givenValues_whenUsingParse_thenLocalDate() {
+        assertEquals("2020-01-08", date.getDateFromString("2020-01-08"));
+    }
+
+    @Test
+    public void givenValuesWithFormatter_whenUsingParse_thenLocalDate() {
+        assertEquals("2020-01-08", date.getDateFromStringAndFormatter("8-Jan-2020", "d-MMM-yyyy"));
+    }
+}

core-java-modules/core-java-io-apis/src/test/java/com/baeldung/file/FileClassUnitTest.java

@@ -1,5 +1,6 @@
 package com.baeldung.file;
 
+import org.junit.Ignore;
 import org.junit.Test;
 
 import java.io.*;
@@ -73,6 +74,7 @@ public class FileClassUnitTest {
         assertFalse(writable);
     }
 
+    @Ignore
     @Test
     public void givenWriteOnlyFile_whenCreateNewFile_thenCantReadFile() {
         File parentDir = makeDir("writeDir");