Merge pull request #17 from eugenp/master

update

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-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/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();
+    }
+
+}

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

@@ -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-java-modules/core-java-concurrency-advanced-3/pom.xml

@@ -23,6 +23,37 @@
             <version>${assertj.version}</version>
             <scope>test</scope>
         </dependency>
+        
+        <dependency>
+            <groupId>com.jcabi</groupId>
+            <artifactId>jcabi-aspects</artifactId>
+            <version>${jcabi-aspects.version}</version>
+        </dependency>
+        
+        <dependency>
+            <groupId>org.aspectj</groupId>
+            <artifactId>aspectjrt</artifactId>
+            <version>${aspectjrt.version}</version>
+            <scope>runtime</scope>
+        </dependency>
+        
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>${guava.version}</version>
+        </dependency>
+        
+        <dependency>
+            <groupId>org.cactoos</groupId>
+            <artifactId>cactoos</artifactId>
+            <version>${cactoos.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.ea.async</groupId>
+            <artifactId>ea-async</artifactId>
+            <version>${ea-async.version}</version>
+        </dependency>
     </dependencies>
 
     <build>
@@ -36,6 +67,30 @@
                     <target>${maven.compiler.target}</target>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>com.jcabi</groupId>
+                <artifactId>jcabi-maven-plugin</artifactId>
+                <version>${jcabi-maven-plugin.version}</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>ajc</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <dependencies>
+                    <dependency>
+                        <groupId>org.aspectj</groupId>
+                        <artifactId>aspectjtools</artifactId>
+                        <version>${aspectjtools.version}</version>
+                    </dependency>
+                    <dependency>
+                        <groupId>org.aspectj</groupId>
+                        <artifactId>aspectjweaver</artifactId>
+                        <version>${aspectjweaver.version}</version>
+                    </dependency>
+                </dependencies>
+            </plugin>
         </plugins>
         <resources>
             <resource>
@@ -49,6 +104,14 @@
         <assertj.version>3.14.0</assertj.version>
         <maven.compiler.source>1.8</maven.compiler.source>
         <maven.compiler.target>1.8</maven.compiler.target>
+        <jcabi-aspects.version>0.22.6</jcabi-aspects.version>
+        <aspectjrt.version>1.9.5</aspectjrt.version>
+        <guava.version>28.2-jre</guava.version>
+        <cactoos.version>0.43</cactoos.version>
+        <ea-async.version>1.2.3</ea-async.version>
+        <jcabi-maven-plugin.version>0.14.1</jcabi-maven-plugin.version>
+        <aspectjtools.version>1.9.1</aspectjtools.version>
+        <aspectjweaver.version>1.9.1</aspectjweaver.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-date-operations-2/pom.xml

@@ -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/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/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/src/main/java/com/baeldung/datebasics/CreateDate.java

@@ -0,0 +1,45 @@
+package com.baeldung.datebasics;
+
+import java.time.Clock;
+import java.time.LocalDate;
+import java.time.Month;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+
+public class CreateDate {
+	public LocalDate getTodaysDate() {
+		return LocalDate.now();
+	}
+
+	public LocalDate getTodaysDateFromClock() {
+		return LocalDate.now(Clock.systemDefaultZone());
+	}
+
+	public LocalDate getTodaysDateFromZone(String zone) {
+		return LocalDate.now(ZoneId.of(zone));
+	}
+
+	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/src/test/java/com/baeldung/datebasics/CreateDateUnitTest.java

@@ -0,0 +1,56 @@
+package com.baeldung.datebasics;
+
+import static org.junit.Assert.assertEquals;
+
+import java.time.Month;
+
+import org.junit.Test;
+
+public class CreateDateUnitTest {
+    private CreateDate date = new CreateDate();
+    
+    @Test
+    public void whenUsingNowMethod_thenLocalDate() {
+        assertEquals("2020-01-08", date.getTodaysDate());
+    }
+    
+    @Test
+    public void whenUsingClock_thenLocalDate() {
+        assertEquals("2020-01-08", date.getTodaysDateFromClock());
+    }
+    
+    @Test
+    public void givenValues_whenUsingZone_thenLocalDate() {
+        assertEquals("2020-01-08", date.getTodaysDateFromZone("Asia/Kolkata"));
+    }
+    
+    @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-lang-operators/src/test/java/com/baeldung/ternaryoperator/TernaryOperatorUnitTest.java

@@ -6,7 +6,7 @@ import org.junit.Test;
 public class TernaryOperatorUnitTest {
 
     @Test
-    public void givenACondition_whenUsingTernaryOperator_thenItEvaluatesConditionAndReturnsAValue() {
+    public void whenUsingTernaryOperator_thenConditionIsEvaluatedAndValueReturned() {
         int number = 10;
         String msg = number > 10 ? "Number is greater than 10" : "Number is less than or equal to 10";
 
@@ -14,7 +14,7 @@ public class TernaryOperatorUnitTest {
     }
 
     @Test
-    public void givenATrueCondition_whenUsingTernaryOperator_thenOnlyExpression1IsEvaluated() {
+    public void whenConditionIsTrue_thenOnlyFirstExpressionIsEvaluated() {
         int exp1 = 0, exp2 = 0;
         int result = 12 > 10 ? ++exp1 : ++exp2;
 
@@ -24,7 +24,7 @@ public class TernaryOperatorUnitTest {
     }
 
     @Test
-    public void givenAFalseCondition_whenUsingTernaryOperator_thenOnlyExpression2IsEvaluated() {
+    public void whenConditionIsFalse_thenOnlySecondExpressionIsEvaluated() {
         int exp1 = 0, exp2 = 0;
         int result = 8 > 10 ? ++exp1 : ++exp2;
 

data-structures/pom.xml

@@ -12,6 +12,21 @@
         <version>1.0.0-SNAPSHOT</version>
     </parent>
 
+    <repositories>
+        <repository>
+            <id>github.release.repo</id>
+            <url>https://raw.github.com/bulldog2011/bulldog-repo/master/repo/releases/</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.leansoft</groupId>
+            <artifactId>bigqueue</artifactId>
+            <version>0.7.0</version>
+        </dependency>
+    </dependencies>
+
     <build>
         <pluginManagement>
             <plugins>

data-structures/src/test/java/com/baeldung/bigqueue/BigQueueLiveTest.java

@@ -0,0 +1,82 @@
+package com.baeldung.bigqueue;
+
+import com.leansoft.bigqueue.BigQueueImpl;
+import com.leansoft.bigqueue.IBigQueue;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.IOException;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@RunWith(JUnit4.class)
+public class BigQueueLiveTest {
+
+    private IBigQueue bigQueue;
+
+    @Before
+    public void setup() throws IOException {
+        String queueDir = System.getProperty("user.home");
+        String queueName = "baeldung-queue";
+        bigQueue = new BigQueueImpl(queueDir, queueName);
+    }
+
+    @After
+    public void emptyQueue() throws IOException {
+        bigQueue.removeAll();
+        bigQueue.gc();
+        bigQueue.close();
+    }
+
+    @Test
+    public void whenAddingRecords_ThenTheSizeIsCorrect() throws IOException {
+        for (int i = 1; i <= 100; i++) {
+            bigQueue.enqueue(String.valueOf(i).getBytes());
+        }
+
+        assertEquals(100, bigQueue.size());
+    }
+
+    @Test
+    public void whenAddingRecords_ThenTheyCanBeRetrieved() throws IOException {
+        bigQueue.enqueue(String.valueOf("new_record").getBytes());
+
+        String record = new String(bigQueue.dequeue());
+        assertEquals("new_record", record);
+    }
+
+    @Test
+    public void whenDequeueingRecords_ThenTheyAreConsumed() throws IOException {
+        for (int i = 1; i <= 100; i++) {
+            bigQueue.enqueue(String.valueOf(i).getBytes());
+        }
+        bigQueue.dequeue();
+
+        assertEquals(99, bigQueue.size());
+    }
+
+    @Test
+    public void whenPeekingRecords_ThenSizeDoesntChange() throws IOException {
+        for (int i = 1; i <= 100; i++) {
+            bigQueue.enqueue(String.valueOf(i).getBytes());
+        }
+        String firstRecord = new String(bigQueue.peek());
+
+        assertEquals("1", firstRecord);
+        assertEquals(100, bigQueue.size());
+    }
+
+    @Test
+    public void whenEmptyingTheQueue_ThenItSizeIs0() throws IOException {
+        for (int i = 1; i <= 100; i++) {
+            bigQueue.enqueue(String.valueOf(i).getBytes());
+        }
+        bigQueue.removeAll();
+
+        assertEquals(0, bigQueue.size());
+    }
+
+}

java-numbers-3/pom.xml

@@ -12,6 +12,14 @@
         <version>0.0.1-SNAPSHOT</version>
         <relativePath>../parent-java</relativePath>
     </parent>
+    
+    <dependencies>
+    	<dependency>
+            <groupId>it.unimi.dsi</groupId>
+            <artifactId>dsiutils</artifactId>
+            <version>2.6.0</version>
+        </dependency>
+    </dependencies>
    
     <build>
         <finalName>java-numbers-3</finalName>

java-numbers-3/src/main/java/com/baeldung/randomnumbers/RandomNumbersGenerator.java

@@ -0,0 +1,103 @@
+package com.baeldung.randomnumbers;
+
+import java.security.SecureRandom;
+import java.util.Random;
+import java.util.SplittableRandom;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.stream.IntStream;
+
+import org.apache.commons.math3.random.RandomDataGenerator;
+
+import it.unimi.dsi.util.XoRoShiRo128PlusRandom;
+
+public class RandomNumbersGenerator {
+
+    public Integer generateRandomWithMathRandom(int max, int min) {
+        return (int) ((Math.random() * (max - min)) + min);
+    }
+
+    public Integer generateRandomWithNextInt() {
+        Random random = new Random();
+        int randomWithNextInt = random.nextInt();
+        return randomWithNextInt;
+    }
+
+    public Integer generateRandomWithNextIntWithinARange(int min, int max) {
+        Random random = new Random();
+        int randomWintNextIntWithinARange = random.nextInt(max - min) + min;
+        return randomWintNextIntWithinARange;
+    }
+
+    public IntStream generateRandomUnlimitedIntStream() {
+        Random random = new Random();
+        IntStream unlimitedIntStream = random.ints();
+        return unlimitedIntStream;
+    }
+
+    public IntStream generateRandomLimitedIntStream(long streamSize) {
+        Random random = new Random();
+        IntStream limitedIntStream = random.ints(streamSize);
+        return limitedIntStream;
+    }
+
+    public IntStream generateRandomLimitedIntStreamWithinARange(int min, int max, long streamSize) {
+        Random random = new Random();
+        IntStream limitedIntStreamWithinARange = random.ints(streamSize, min, max);
+        return limitedIntStreamWithinARange;
+    }
+
+    public Integer generateRandomWithThreadLocalRandom() {
+        int randomWithThreadLocalRandom = ThreadLocalRandom.current()
+            .nextInt();
+        return randomWithThreadLocalRandom;
+    }
+
+    public Integer generateRandomWithThreadLocalRandomInARange(int min, int max) {
+        int randomWithThreadLocalRandomInARange = ThreadLocalRandom.current()
+            .nextInt(min, max);
+        return randomWithThreadLocalRandomInARange;
+    }
+
+    public Integer generateRandomWithThreadLocalRandomFromZero(int max) {
+        int randomWithThreadLocalRandomFromZero = ThreadLocalRandom.current()
+            .nextInt(max);
+        return randomWithThreadLocalRandomFromZero;
+    }
+
+    public Integer generateRandomWithSplittableRandom(int min, int max) {
+        SplittableRandom splittableRandom = new SplittableRandom();
+        int randomWithSplittableRandom = splittableRandom.nextInt(min, max);
+        return randomWithSplittableRandom;
+    }
+
+    public IntStream generateRandomWithSplittableRandomLimitedIntStreamWithinARange(int min, int max, long streamSize) {
+        SplittableRandom splittableRandom = new SplittableRandom();
+        IntStream limitedIntStreamWithinARangeWithSplittableRandom = splittableRandom.ints(streamSize, min, max);
+        return limitedIntStreamWithinARangeWithSplittableRandom;
+    }
+
+    public Integer generateRandomWithSecureRandom() {
+        SecureRandom secureRandom = new SecureRandom();
+        int randomWithSecureRandom = secureRandom.nextInt();
+        return randomWithSecureRandom;
+    }
+
+    public Integer generateRandomWithSecureRandomWithinARange(int min, int max) {
+        SecureRandom secureRandom = new SecureRandom();
+        int randomWithSecureRandomWithinARange = secureRandom.nextInt(max - min) + min;
+        return randomWithSecureRandomWithinARange;
+    }
+
+    public Integer generateRandomWithRandomDataGenerator(int min, int max) {
+        RandomDataGenerator randomDataGenerator = new RandomDataGenerator();
+        int randomWithRandomDataGenerator = randomDataGenerator.nextInt(min, max);
+        return randomWithRandomDataGenerator;
+    }
+
+    public Integer generateRandomWithXoRoShiRo128PlusRandom(int min, int max) {
+        XoRoShiRo128PlusRandom xoroRandom = new XoRoShiRo128PlusRandom();
+        int randomWithXoRoShiRo128PlusRandom = xoroRandom.nextInt(max - min) + min;
+        return randomWithXoRoShiRo128PlusRandom;
+    }
+
+}

java-numbers-3/src/test/java/com/baeldung/randomnumbers/RandomNumbersGeneratorUnitTest.java

@@ -0,0 +1,154 @@
+package com.baeldung.randomnumbers;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.stream.IntStream;
+
+import org.junit.Test;
+
+public class RandomNumbersGeneratorUnitTest {
+
+    private static final int MIN_RANGE = 1;
+    private static final int MAX_RANGE = 10;
+    private static final int MIN_RANGE_NEGATIVE = -10;    
+    private static final int ITERATIONS = 50;
+    private static final long STREAM_SIZE = 50;
+
+    @Test
+    public void whenGenerateRandomWithMathRandom_returnsSuccessfully() {
+        RandomNumbersGenerator generator = new RandomNumbersGenerator();
+        for (int i = 0; i < ITERATIONS; i++) {
+            int randomNumer = generator.generateRandomWithMathRandom(MIN_RANGE, MAX_RANGE);
+            assertTrue(isInRange(randomNumer, MIN_RANGE, MAX_RANGE));
+        }
+    }
+
+    @Test
+    public void whenGenerateRandomWithNextInt_returnsSuccessfully() {
+        RandomNumbersGenerator generator = new RandomNumbersGenerator();
+        for (int i = 0; i < ITERATIONS; i++) {
+            int randomNumber = generator.generateRandomWithNextInt();
+            assertTrue(isInRange(randomNumber, Integer.MIN_VALUE, Integer.MAX_VALUE));
+        }
+    }
+
+    @Test
+    public void whenGenerateRandomWithNextIntWithinARange_returnsSuccessfully() {
+        RandomNumbersGenerator generator = new RandomNumbersGenerator();
+        for (int i = 0; i < ITERATIONS; i++) {
+            int randomNumber = generator.generateRandomWithNextIntWithinARange(MIN_RANGE, MAX_RANGE);
+            assertTrue(isInRange(randomNumber, MIN_RANGE, MAX_RANGE));
+        }
+    }
+
+    @Test
+    public void whenGenerateRandomUnlimitedIntStream_returnsSuccessfully() {
+        RandomNumbersGenerator generator = new RandomNumbersGenerator();
+        IntStream stream = generator.generateRandomUnlimitedIntStream();
+        assertNotNull(stream);
+        Integer randomNumber = stream.findFirst()
+            .getAsInt();
+        assertNotNull(randomNumber);
+        assertTrue(isInRange(randomNumber, Integer.MIN_VALUE, Integer.MAX_VALUE));
+    }
+
+    @Test
+    public void whenGenerateRandomLimitedIntStream_returnsSuccessfully() {
+        RandomNumbersGenerator generator = new RandomNumbersGenerator();
+        generator.generateRandomLimitedIntStream(STREAM_SIZE)
+            .forEach(randomNumber -> assertTrue(isInRange(randomNumber, Integer.MIN_VALUE, Integer.MAX_VALUE)));
+    }
+
+    @Test
+    public void whenGenerateRandomLimitedIntStreamWithinARange_returnsSuccessfully() {
+        RandomNumbersGenerator generator = new RandomNumbersGenerator();
+        generator.generateRandomLimitedIntStreamWithinARange(MIN_RANGE, MAX_RANGE, STREAM_SIZE)
+            .forEach(randomNumber -> assertTrue(isInRange(randomNumber, MIN_RANGE, MAX_RANGE)));
+    }
+
+    @Test
+    public void whenGenerateRandomWithThreadLocalRandom_returnsSuccessfully() {
+        RandomNumbersGenerator generator = new RandomNumbersGenerator();
+        for (int i = 0; i < ITERATIONS; i++) {
+            int randomNumber = generator.generateRandomWithThreadLocalRandom();
+            assertTrue(isInRange(randomNumber, Integer.MIN_VALUE, Integer.MAX_VALUE));
+        }
+    }
+
+    @Test
+    public void whenGenerateRandomWithThreadLocalRandomInARange_returnsSuccessfully() {
+        RandomNumbersGenerator generator = new RandomNumbersGenerator();
+        for (int i = 0; i < ITERATIONS; i++) {
+            int randomNumber = generator.generateRandomWithThreadLocalRandomInARange(MIN_RANGE, MAX_RANGE);
+            assertTrue(isInRange(randomNumber, MIN_RANGE, MAX_RANGE));
+        }
+    }
+
+    @Test
+    public void whenGenerateRandomWithThreadLocalRandomFromZero_returnsSuccessfully() {
+        RandomNumbersGenerator generator = new RandomNumbersGenerator();
+        for (int i = 0; i < ITERATIONS; i++) {
+            int randomNumber = generator.generateRandomWithThreadLocalRandomFromZero(MAX_RANGE);
+            assertTrue(isInRange(randomNumber, 0, MAX_RANGE));
+        }
+    }
+
+    @Test
+    public void whenGenerateRandomWithSplittableRandom_returnsSuccessfully() {
+        RandomNumbersGenerator generator = new RandomNumbersGenerator();
+        for (int i = 0; i < ITERATIONS; i++) {
+            int randomNumber = generator.generateRandomWithSplittableRandom(MIN_RANGE_NEGATIVE, MAX_RANGE);
+            assertTrue(isInRange(randomNumber, MIN_RANGE_NEGATIVE, MAX_RANGE));
+        }
+    }
+    
+    @Test
+    public void whenGenerateRandomWithSplittableRandomLimitedIntStreamWithinARange_returnsSuccessfully() {
+        RandomNumbersGenerator generator = new RandomNumbersGenerator();
+        generator.generateRandomWithSplittableRandomLimitedIntStreamWithinARange(MIN_RANGE, MAX_RANGE, STREAM_SIZE)
+            .forEach(randomNumber -> assertTrue(isInRange(randomNumber, MIN_RANGE, MAX_RANGE)));
+    }        
+
+    @Test
+    public void whenGenerateRandomWithSecureRandom_returnsSuccessfully() {
+        RandomNumbersGenerator generator = new RandomNumbersGenerator();
+        for (int i = 0; i < ITERATIONS; i++) {
+            int randomNumber = generator.generateRandomWithSecureRandom();
+            assertTrue(isInRange(randomNumber, Integer.MIN_VALUE, Integer.MAX_VALUE));
+        }
+    }
+    
+    @Test
+    public void whenGenerateRandomWithSecureRandomWithinARange_returnsSuccessfully() {
+        RandomNumbersGenerator generator = new RandomNumbersGenerator();
+        for (int i = 0; i < ITERATIONS; i++) {
+            int randomNumber = generator.generateRandomWithSecureRandomWithinARange(MIN_RANGE, MAX_RANGE);
+            assertTrue(isInRange(randomNumber, MIN_RANGE, MAX_RANGE));
+        }
+    }
+
+    @Test
+    public void whenGenerateRandomWithRandomDataGenerator_returnsSuccessfully() {
+        RandomNumbersGenerator generator = new RandomNumbersGenerator();
+        for (int i = 0; i < ITERATIONS; i++) {
+            int randomNumber = generator.generateRandomWithRandomDataGenerator(MIN_RANGE, MAX_RANGE);
+            // RandomDataGenerator top is inclusive
+            assertTrue(isInRange(randomNumber, MIN_RANGE, MAX_RANGE + 1));
+        }
+    }
+
+    @Test
+    public void whenGenerateRandomWithXoRoShiRo128PlusRandom_returnsSuccessfully() {
+        RandomNumbersGenerator generator = new RandomNumbersGenerator();
+        for (int i = 0; i < ITERATIONS; i++) {
+            int randomNumber = generator.generateRandomWithXoRoShiRo128PlusRandom(MIN_RANGE, MAX_RANGE);
+            assertTrue(isInRange(randomNumber, MIN_RANGE, MAX_RANGE));
+        }
+    }
+
+    private boolean isInRange(int number, int min, int max) {
+        return min <= number && number < max;
+    }
+
+}

libraries-3/pom.xml

@@ -23,10 +23,16 @@
             <artifactId>lombok</artifactId>
             <version>${lombok.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.cactoos</groupId>
+            <artifactId>cactoos</artifactId>
+            <version>${cactoos.version}</version>
+        </dependency>
     </dependencies>
 
     <properties>
         <jcommander.version>1.78</jcommander.version>
         <lombok.version>1.18.6</lombok.version>
+        <cactoos.version>0.43</cactoos.version>
     </properties>
-</project>
+</project>

libraries-3/src/main/java/com/baeldung/cactoos/CactoosCollectionUtils.java

@@ -0,0 +1,28 @@
+package com.baeldung.cactoos;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.cactoos.collection.Filtered;
+import org.cactoos.iterable.IterableOf;
+import org.cactoos.list.ListOf;
+import org.cactoos.scalar.And;
+import org.cactoos.text.FormattedText;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class CactoosCollectionUtils {
+
+	final Logger LOGGER = LoggerFactory.getLogger(CactoosCollectionUtils.class);
+
+	public void iterateCollection(List<String> strings) throws Exception {
+		new And((String input) -> LOGGER.info(new FormattedText("%s\n", input).asString()), strings).value();
+	}
+
+	public Collection<String> getFilteredList(List<String> strings) {
+		Collection<String> filteredStrings = new ListOf<>(
+				new Filtered<>(string -> string.length() == 5, new IterableOf<>(strings)));
+		return filteredStrings;
+	}
+
+}

libraries-3/src/main/java/com/baeldung/cactoos/CactoosStringUtils.java

@@ -0,0 +1,37 @@
+package com.baeldung.cactoos;
+
+import java.io.IOException;
+
+import org.cactoos.text.FormattedText;
+import org.cactoos.text.IsBlank;
+import org.cactoos.text.Lowered;
+import org.cactoos.text.TextOf;
+import org.cactoos.text.Upper;
+
+public class CactoosStringUtils {
+
+	public String createString() throws IOException {
+		String testString = new TextOf("Test String").asString();
+		return testString;
+	}
+
+	public String createdFormattedString(String stringToFormat) throws IOException {
+		String formattedString = new FormattedText("Hello %s", stringToFormat).asString();
+		return formattedString;
+	}
+
+	public String toLowerCase(String testString) throws IOException {
+		String lowerCaseString = new Lowered(new TextOf(testString)).asString();
+		return lowerCaseString;
+	}
+
+	public String toUpperCase(String testString) throws Exception {
+		String upperCaseString = new Upper(new TextOf(testString)).asString();
+		return upperCaseString;
+	}
+
+	public boolean isBlank(String testString) throws Exception {
+		return new IsBlank(new TextOf(testString)) != null;
+	}
+
+}

libraries-3/src/test/java/com/baeldung/cactoos/CactoosCollectionUtilsUnitTest.java

@@ -0,0 +1,35 @@
+package com.baeldung.cactoos;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.ArrayList;
+
+import org.junit.Test;
+
+public class CactoosCollectionUtilsUnitTest {
+
+	@Test
+	public void whenFilteredClassIsCalledWithSpecificArgs_thenCorrespondingFilteredCollectionShouldBeReturned() throws IOException {
+
+		CactoosCollectionUtils obj = new CactoosCollectionUtils();
+
+		// when
+		List<String> strings = new ArrayList<String>() { 
+            { 
+                add("Hello"); 
+                add("John"); 
+                add("Smith"); 
+                add("Eric");
+                add("Dizzy");
+            } 
+        }; 
+		int size = obj.getFilteredList(strings).size();
+
+		// then
+		assertEquals(3, size);
+
+	}
+
+}

libraries-3/src/test/java/com/baeldung/cactoos/CactoosStringUtilsUnitTest.java

@@ -0,0 +1,54 @@
+package com.baeldung.cactoos;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+
+import org.junit.Test;
+
+public class CactoosStringUtilsUnitTest {
+
+	@Test
+	public void whenFormattedTextIsPassedWithArgs_thenFormattedStringIsReturned() throws IOException {
+
+		CactoosStringUtils obj = new CactoosStringUtils();
+
+		// when
+		String formattedString = obj.createdFormattedString("John");
+
+		// then
+		assertEquals("Hello John", formattedString);
+
+	}
+	
+	@Test
+	public void whenStringIsPassesdToLoweredOrUpperClass_thenCorrespondingStringIsReturned() throws Exception {
+
+		CactoosStringUtils obj = new CactoosStringUtils();
+
+		// when
+		String lowerCaseString = obj.toLowerCase("TeSt StrIng");
+		String upperCaseString = obj.toUpperCase("TeSt StrIng");
+
+		// then
+		assertEquals("test string", lowerCaseString);
+		assertEquals("TEST STRING", upperCaseString);
+
+	}
+	
+	@Test
+	public void whenEmptyStringIsPassesd_thenIsBlankReturnsTrue() throws Exception {
+
+		CactoosStringUtils obj = new CactoosStringUtils();
+
+		// when
+		boolean isBlankEmptyString = obj.isBlank("");
+		boolean isBlankNull = obj.isBlank(null);
+
+		// then
+		assertEquals(true, isBlankEmptyString);
+		assertEquals(true, isBlankNull);
+
+	}
+
+}

persistence-modules/spring-persistence-simple/src/main/java/com/baeldung/config/PersistenceJPAConfig.java

@@ -15,6 +15,7 @@ import org.springframework.dao.annotation.PersistenceExceptionTranslationPostPro
 import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
 import org.springframework.jdbc.datasource.DriverManagerDataSource;
 import org.springframework.orm.jpa.JpaTransactionManager;
+import org.springframework.orm.jpa.JpaVendorAdapter;
 import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
 import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
 import org.springframework.transaction.PlatformTransactionManager;
@@ -39,12 +40,12 @@ public class PersistenceJPAConfig {
     // beans
 
     @Bean
-    public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean() {
+    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
         final LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
         em.setDataSource(dataSource());
         em.setPackagesToScan(new String[] { "com.baeldung.persistence.model" });
 
-        final HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
+        final JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
         em.setJpaVendorAdapter(vendorAdapter);
         em.setJpaProperties(additionalProperties());
 

persistence-modules/spring-persistence-simple/src/test/java/com/baeldung/persistence/service/transactional/PersistenceTransactionalTestConfig.java

@@ -14,6 +14,7 @@ import org.springframework.dao.annotation.PersistenceExceptionTranslationPostPro
 import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
 import org.springframework.jdbc.datasource.DriverManagerDataSource;
 import org.springframework.orm.jpa.JpaTransactionManager;
+import org.springframework.orm.jpa.JpaVendorAdapter;
 import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
 import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
 import org.springframework.transaction.PlatformTransactionManager;
@@ -91,12 +92,12 @@ public class PersistenceTransactionalTestConfig {
     // beans
 
     @Bean
-    public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean() {
+    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
         final LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
         em.setDataSource(dataSource());
         em.setPackagesToScan(new String[] { "com.baeldung.persistence.model" });
 
-        final HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
+        final JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
         em.setJpaVendorAdapter(vendorAdapter);
         em.setJpaProperties(additionalProperties());
 

pom.xml

@@ -341,6 +341,7 @@
                 <module>algorithms-miscellaneous-4</module>
                 <module>algorithms-miscellaneous-5</module>
                 <module>algorithms-sorting</module>
+                <module>algorithms-sorting-2</module>
                 <module>algorithms-searching</module>
                 <module>animal-sniffer-mvn-plugin</module>
                 <module>annotations</module>
@@ -985,6 +986,7 @@
                 <module>algorithms-miscellaneous-4</module>
                 <module>algorithms-miscellaneous-5</module>
                 <module>algorithms-sorting</module>
+                <module>algorithms-sorting-2</module>
                 <module>algorithms-searching</module>
                 <module>animal-sniffer-mvn-plugin</module>
                 <module>annotations</module>

spring-boot-admin/pom.xml

@@ -11,6 +11,7 @@
         <groupId>com.baeldung</groupId>
         <artifactId>parent-boot-2</artifactId>
         <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../parent-boot-2</relativePath>
     </parent>
 
     <modules>

spring-boot-properties/src/test/java/com/baeldung/properties/testproperty/FilePropertyInjectionUnitTest.java

@@ -0,0 +1,24 @@
+package com.baeldung.properties.testproperty;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(SpringRunner.class)
+@TestPropertySource("/foo.properties")
+public class FilePropertyInjectionUnitTest {
+
+    @Value("${foo}")
+    private String foo;
+
+    @Test
+    public void whenFilePropertyProvided_thenProperlyInjected() {
+        assertThat(foo).isEqualTo("bar");
+    }
+}

spring-boot-properties/src/test/java/com/baeldung/properties/testproperty/PropertyInjectionUnitTest.java

@@ -0,0 +1,23 @@
+package com.baeldung.properties.testproperty;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(SpringRunner.class)
+@TestPropertySource(properties = {"foo=bar"})
+public class PropertyInjectionUnitTest {
+
+    @Value("${foo}")
+    private String foo;
+
+    @Test
+    public void whenPropertyProvided_thenProperlyInjected() {
+        assertThat(foo).isEqualTo("bar");
+    }
+}

spring-boot-properties/src/test/java/com/baeldung/properties/testproperty/SpringBootPropertyInjectionIntegrationTest.java

@@ -0,0 +1,23 @@
+package com.baeldung.properties.testproperty;
+
+import com.baeldung.properties.reloading.SpringBootPropertiesTestApplication;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(properties = {"foo=bar"}, classes = SpringBootPropertiesTestApplication.class)
+public class SpringBootPropertyInjectionIntegrationTest {
+
+    @Value("${foo}")
+    private String foo;
+
+    @Test
+    public void whenSpringBootPropertyProvided_thenProperlyInjected() {
+        assertThat(foo).isEqualTo("bar");
+    }
+}

spring-boot-properties/src/test/resources/foo.properties

@@ -0,0 +1 @@
+foo=bar

spring-boot/pom.xml

@@ -7,16 +7,17 @@
     <name>spring-boot</name>
     <packaging>war</packaging>
     <description>This is simple boot application for Spring boot actuator test</description>
+    <version>0.0.1-SNAPSHOT</version>
 
     <parent>
-        <groupId>com.baeldung</groupId>
         <artifactId>parent-boot-2</artifactId>
+        <groupId>com.baeldung</groupId>
         <version>0.0.1-SNAPSHOT</version>
         <relativePath>../parent-boot-2</relativePath>
     </parent>
 
     <dependencies>
-
+      
         <!-- JUnit Jupiter dependencies -->
         <dependency>
             <groupId>org.junit.jupiter</groupId>
@@ -198,6 +199,16 @@
                 </configuration>
             </plugin>
 
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-resources-plugin</artifactId>
+                <configuration>
+                    <delimiters>
+                        <delimiter>@</delimiter>
+                    </delimiters>
+                    <useDefaultDelimiters>false</useDefaultDelimiters>
+                </configuration>
+            </plugin>
         </plugins>
 
     </build>
@@ -251,6 +262,7 @@
         <graphql-java-tools.version>5.2.4</graphql-java-tools.version>
         <guava.version>18.0</guava.version>
         <git-commit-id-plugin.version>2.2.4</git-commit-id-plugin.version>
+        <resource.delimiter>@</resource.delimiter>
     </properties>
 
 </project>

spring-boot/src/main/java/com/baeldung/buildproperties/Application.java

@@ -0,0 +1,18 @@
+package com.baeldung.buildproperties;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.PropertySource;
+
+@SpringBootApplication
+@ComponentScan(basePackages = "com.baeldung.buildproperties")
+@PropertySource("classpath:build.properties")
+//@PropertySource("classpath:build.yml")
+public class Application {
+    
+    public static void main(String[] args) {
+        SpringApplication.run(Application.class, args);
+    }
+    
+}

spring-boot/src/main/java/com/baeldung/buildproperties/BuildInfoService.java

@@ -0,0 +1,21 @@
+package com.baeldung.buildproperties;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+@Service
+public class BuildInfoService {
+    @Value("${application-description}")
+    private String applicationDescription;
+    
+    @Value("${application-version}")
+    private String applicationVersion;
+
+    public String getApplicationDescription() {
+        return applicationDescription;
+    }
+
+    public String getApplicationVersion() {
+        return applicationVersion;
+    }
+}

spring-boot/src/main/resources/build.properties

@@ -0,0 +1,2 @@
+application-description=@project.description@
+application-version=@project.version@

spring-boot/src/main/resources/build.yml

@@ -0,0 +1,2 @@
+application-description: ^project.description^
+application-version: ^project.version^

spring-boot/src/test/java/com/baeldung/buildproperties/BuildInfoServiceIntegrationTest.java

@@ -0,0 +1,24 @@
+package com.baeldung.buildproperties;
+
+import static org.junit.Assert.assertThat;
+
+import org.hamcrest.Matchers;
+import org.junit.jupiter.api.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = Application.class)
+class BuildInfoServiceIntegrationTest {
+
+    @Autowired
+    private BuildInfoService service;
+    
+    @Test
+    void whenGetApplicationDescription_thenSuccess() {
+        assertThat(service.getApplicationDescription(), Matchers.is("This is simple boot application for Spring boot actuator test"));
+        assertThat(service.getApplicationVersion(), Matchers.is("0.0.1-SNAPSHOT"));
+    }
+}

spring-boot/src/test/java/org/baeldung/boot/repository/FooRepositoryIntegrationTest.java

@@ -1,19 +1,17 @@
 package org.baeldung.boot.repository;
 
-import static org.junit.Assert.assertThat;
-
 import org.baeldung.boot.DemoApplicationIntegrationTest;
 import org.baeldung.demo.model.Foo;
 import org.baeldung.demo.repository.FooRepository;
-
-import static org.hamcrest.Matchers.notNullValue;
-import static org.hamcrest.Matchers.is;
-
 import org.junit.Before;
 import org.junit.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.transaction.annotation.Transactional;
 
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.junit.Assert.assertThat;
+
 @Transactional
 public class FooRepositoryIntegrationTest extends DemoApplicationIntegrationTest {
     @Autowired
@@ -28,8 +26,10 @@ public class FooRepositoryIntegrationTest extends DemoApplicationIntegrationTest
     @Test
     public void testFindByName() {
         Foo foo = fooRepository.findByName("Bar");
+
         assertThat(foo, notNullValue());
-        assertThat(foo.getId(), is(2));
+        assertThat(foo.getId(), notNullValue());
+        assertThat(foo.getName(), is("Bar"));
     }
 
 }

spring-boot/src/test/java/org/baeldung/boot/repository/HibernateSessionIntegrationTest.java

@@ -1,9 +1,5 @@
 package org.baeldung.boot.repository;
 
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.notNullValue;
-import static org.junit.Assert.assertThat;
-
 import org.baeldung.boot.DemoApplicationIntegrationTest;
 import org.baeldung.demo.model.Foo;
 import org.baeldung.demo.repository.FooRepository;
@@ -11,6 +7,10 @@ import org.junit.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.transaction.annotation.Transactional;
 
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.junit.Assert.assertThat;
+
 @Transactional
 public class HibernateSessionIntegrationTest extends DemoApplicationIntegrationTest {
     @Autowired
@@ -18,13 +18,12 @@ public class HibernateSessionIntegrationTest extends DemoApplicationIntegrationT
 
     @Test
     public void whenSavingWithCurrentSession_thenThrowNoException() {
-        Foo foo = new Foo("Exception Solved");
+        fooRepository.save(new Foo("Exception Solved"));
-        fooRepository.save(foo);
+
-        foo = null;
+        Foo foo = fooRepository.findByName("Exception Solved");
-        foo = fooRepository.findByName("Exception Solved");
 
         assertThat(foo, notNullValue());
-        assertThat(foo.getId(), is(1));
+        assertThat(foo.getId(), notNullValue());
         assertThat(foo.getName(), is("Exception Solved"));
     }
 }

spring-exceptions/README.md

@@ -1,4 +1,4 @@
-## Spring `Exception`s
+## Spring Exceptions
 
 This module contains articles about Spring `Exception`s
 

spring-mvc-views/src/main/java/com/baeldung/themes/config/DataSourceConfig.java

@@ -1,4 +1,4 @@
-package com.baeldung.config;
+package com.baeldung.themes.config;
 
 import org.springframework.context.annotation.Bean;
 import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
@@ -27,7 +27,7 @@ public class DataSourceConfig {
     public LocalContainerEntityManagerFactoryBean entityManagerFactory(DataSource dataSource) {
         LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
         em.setDataSource(dataSource);
-        em.setPackagesToScan("com.baeldung.domain");
+        em.setPackagesToScan("com.baeldung.themes.domain");
         em.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
         return em;
     }

spring-mvc-views/src/main/java/com/baeldung/themes/config/InitSecurity.java

@@ -1,4 +1,4 @@
-package com.baeldung.config;
+package com.baeldung.themes.config;
 
 import org.springframework.security.web.context.AbstractSecurityWebApplicationInitializer;
 

spring-mvc-views/src/main/java/com/baeldung/themes/config/SecurityConfig.java

@@ -1,4 +1,4 @@
-package com.baeldung.config;
+package com.baeldung.themes.config;
 
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Bean;

spring-mvc-views/src/main/java/com/baeldung/themes/config/ThemeMVCConfig.java

@@ -1,6 +1,6 @@
-package com.baeldung.config;
+package com.baeldung.themes.config;
 
-import com.baeldung.theme.resolver.UserPreferenceThemeResolver;
+import com.baeldung.themes.resolver.UserPreferenceThemeResolver;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.Configuration;

spring-mvc-views/src/main/java/com/baeldung/themes/config/WebInitializer.java

@@ -1,4 +1,4 @@
-package com.baeldung.config;
+package com.baeldung.themes.config;
 
 import org.springframework.web.WebApplicationInitializer;
 import org.springframework.web.context.ContextLoaderListener;

spring-mvc-views/src/main/java/com/baeldung/themes/controllers/AppController.java

@@ -1,4 +1,4 @@
-package com.baeldung.controllers;
+package com.baeldung.themes.controllers;
 
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.RequestMapping;

spring-mvc-views/src/main/java/com/baeldung/themes/domain/UserPreference.java

@@ -1,4 +1,4 @@
-package com.baeldung.domain;
+package com.baeldung.themes.domain;
 
 import javax.persistence.Entity;
 import javax.persistence.Id;

spring-mvc-views/src/main/java/com/baeldung/themes/repository/UserPreferenceRepository.java

@@ -1,6 +1,6 @@
-package com.baeldung.repository;
+package com.baeldung.themes.repository;
 
-import com.baeldung.domain.UserPreference;
+import com.baeldung.themes.domain.UserPreference;
 import org.springframework.data.repository.PagingAndSortingRepository;
 
 public interface UserPreferenceRepository extends PagingAndSortingRepository<UserPreference, String> {

spring-mvc-views/src/main/java/com/baeldung/themes/resolver/UserPreferenceThemeResolver.java

@@ -1,7 +1,7 @@
-package com.baeldung.theme.resolver;
+package com.baeldung.themes.resolver;
 
-import com.baeldung.domain.UserPreference;
+import com.baeldung.themes.domain.UserPreference;
-import com.baeldung.repository.UserPreferenceRepository;
+import com.baeldung.themes.repository.UserPreferenceRepository;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.security.core.Authentication;
 import org.springframework.security.core.context.SecurityContextHolder;

spring-scheduling/pom.xml

@@ -5,7 +5,7 @@
     <artifactId>spring-scheduling</artifactId>
     <version>0.1-SNAPSHOT</version>
     <name>spring-scheduling</name>
-    <packaging>war</packaging>
+    <packaging>jar</packaging>
 
     <parent>
         <groupId>com.baeldung</groupId>

spring-security-modules/spring-security-rest/src/main/java/org/baeldung/security/SecurityWebApplicationInitializer.java

@@ -0,0 +1,10 @@
+package org.baeldung.security;
+
+import org.springframework.security.web.context.AbstractSecurityWebApplicationInitializer;
+
+public class SecurityWebApplicationInitializer extends AbstractSecurityWebApplicationInitializer {
+
+    public SecurityWebApplicationInitializer() {
+        super(SecurityJavaConfig.class);
+    }
+}

testing-modules/mocks/src/test/java/com/baeldung/jmockit/LoginControllerIntegrationTest.java

@@ -130,30 +130,33 @@ public class LoginControllerIntegrationTest {
         };
     }
 
+    
     @Test
     public void partialMocking() {
-        // use partial mock
+        LoginService partialLoginService = new LoginService();
-        final LoginService partialLoginService = new LoginService();
         partialLoginService.setLoginDao(loginDao);
         loginController.loginService = partialLoginService;
 
-        final UserForm userForm = new UserForm();
+        UserForm userForm = new UserForm();
         userForm.username = "foo";
-        // let service's login use implementation so let's mock DAO call
+        
-        new Expectations() {{
+        new Expectations(partialLoginService) {{
-            loginDao.login(userForm);
+            // let's mock DAO call 
-            result = 1;
+            loginDao.login(userForm); result = 1; 
-            // no expectation for loginService.login
+            
+            // no expectation for login method so that real implementation is used 
+            
+            // mock setCurrentUser call 
             partialLoginService.setCurrentUser("foo");
         }};
 
         String login = loginController.login(userForm);
 
         Assert.assertEquals("OK", login);
-        // verify mocked call
+        // verify mocked call 
-        new FullVerifications(partialLoginService) {
+        new Verifications() {{
-        };
+            partialLoginService.setCurrentUser("foo");
-        new FullVerifications(loginDao) {
+        }};
-        };
+
     }
 }