BAEL-3298 Resolving merge conflict

.gitignore

@@ -65,6 +65,7 @@ core-java-io/target_link.txt
 core-java/src/main/java/com/baeldung/manifest/MANIFEST.MF
 ethereum/logs/
 jmeter/src/main/resources/*-JMeter.csv
+ninja/devDb.mv.db
 
 **/node_modules/
 **/dist

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() {
 
@@ -28,10 +31,10 @@ public class UserServerUnitTest extends JUnitRouteTest {
             .assertStatusCode(404);
 
     appRoute.run(HttpRequest.DELETE("/users/1"))
-            .assertStatusCode(200);
+            .assertStatusCode(405);
 
     appRoute.run(HttpRequest.DELETE("/users/42"))
-            .assertStatusCode(200);
+            .assertStatusCode(405);
 
     appRoute.run(HttpRequest.POST("/users")
             .withEntity(HttpEntities.create(ContentTypes.APPLICATION_JSON, zaphod())))

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-2/README.md

@@ -13,4 +13,5 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
 - [Create a Sudoku Solver in Java](https://www.baeldung.com/java-sudoku)
 - [Displaying Money Amounts in Words](https://www.baeldung.com/java-money-into-words)
 - [A Collaborative Filtering Recommendation System in Java](https://www.baeldung.com/java-collaborative-filtering-recommendations)
+- [Implementing A* Pathfinding in Java](https://www.baeldung.com/java-a-star-pathfinding)
 - More articles: [[<-- prev]](/../algorithms-miscellaneous-1) [[next -->]](/../algorithms-miscellaneous-3)

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/slope_one/SlopeOne.java

@@ -98,7 +98,7 @@ public class SlopeOne {
             for (Item j : InputData.items) {
                 if (e.getValue().containsKey(j)) {
                     clean.put(j, e.getValue().get(j));
-                } else {
+                } else if (!clean.containsKey(j)) {
                     clean.put(j, -1.0);
                 }
             }

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/README.md

@@ -10,6 +10,13 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
 - [Find If Two Numbers Are Relatively Prime in Java](https://www.baeldung.com/java-two-relatively-prime-numbers)
 - [Knapsack Problem Implementation in Java](https://www.baeldung.com/java-knapsack)
 - [How to Determine if a Binary Tree is Balanced](https://www.baeldung.com/java-balanced-binary-tree)
-- [The Caesar Cipher in Java](https://www.baeldung.com/java-caesar-cipher)
 - [Overview of Combinatorial Problems in Java](https://www.baeldung.com/java-combinatorial-algorithms)
+- [Prim’s Algorithm](https://www.baeldung.com/java-prim-algorithm)
+- [Maximum Subarray Problem](https://www.baeldung.com/java-maximum-subarray)
+- [How to Merge Two Sorted Arrays](https://www.baeldung.com/java-merge-sorted-arrays)
+- [Median of Stream of Integers using Heap](https://www.baeldung.com/java-stream-integers-median-using-heap)
+- [Kruskal’s Algorithm for Spanning Trees](https://www.baeldung.com/java-spanning-trees-kruskal)
+- [Balanced Brackets Algorithm in Java](https://www.baeldung.com/java-balanced-brackets-algorithm)
+- [Efficiently Merge Sorted Java Sequences](https://www.baeldung.com/java-merge-sorted-sequences)
+- [Introduction to Greedy Algorithms with Java](https://www.baeldung.com/java-greedy-algorithms)
 - More articles: [[<-- prev]](/../algorithms-miscellaneous-4)

algorithms-miscellaneous-5/pom.xml

@@ -37,7 +37,17 @@
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>
-            <version>28.1-jre</version>
+            <version>${guava.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>${jackson.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-commons</artifactId>
+            <version>${junit.platform.version}</version>
         </dependency>
 
         <dependency>
@@ -65,6 +75,9 @@
         <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>
+        <jackson.version>2.10.2</jackson.version>
+        <junit.platform.version>1.6.0</junit.platform.version>
     </properties>
 
 </project>

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/balancedbrackets/BalancedBracketsUsingDeque.java

@@ -0,0 +1,36 @@
+package com.baeldung.algorithms.balancedbrackets;
+
+import java.util.Deque;
+import java.util.LinkedList;
+
+public class BalancedBracketsUsingDeque {
+
+    public boolean isBalanced(String str) {
+        if (null == str || ((str.length() % 2) != 0)) {
+            return false;
+        } else {
+            char[] ch = str.toCharArray();
+            for (char c : ch) {
+                if (!(c == '{' || c == '[' || c == '(' || c == '}' || c == ']' || c == ')')) {
+                    return false;
+                }
+
+            }
+        }
+
+        Deque<Character> deque = new LinkedList<>();
+        for (char ch : str.toCharArray()) {
+            if (ch == '{' || ch == '[' || ch == '(') {
+                deque.addFirst(ch);
+            } else {
+                if (!deque.isEmpty() && ((deque.peekFirst() == '{' && ch == '}') || (deque.peekFirst() == '[' && ch == ']') || (deque.peekFirst() == '(' && ch == ')'))) {
+                    deque.removeFirst();
+                } else {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/balancedbrackets/BalancedBracketsUsingString.java

@@ -0,0 +1,27 @@
+package com.baeldung.algorithms.balancedbrackets;
+
+public class BalancedBracketsUsingString {
+
+    public boolean isBalanced(String str) {
+        if (null == str || ((str.length() % 2) != 0)) {
+            return false;
+        } else {
+            char[] ch = str.toCharArray();
+            for (char c : ch) {
+                if (!(c == '{' || c == '[' || c == '(' || c == '}' || c == ']' || c == ')')) {
+                    return false;
+                }
+
+            }
+        }
+
+        while (str.contains("()") || str.contains("[]") || str.contains("{}")) {
+            str = str.replaceAll("\\(\\)", "")
+                .replaceAll("\\[\\]", "")
+                .replaceAll("\\{\\}", "");
+        }
+        return (str.length() == 0);
+
+    }
+
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/boruvka/BoruvkaMST.java

@@ -0,0 +1,61 @@
+package com.baeldung.algorithms.boruvka;
+
+public class BoruvkaMST {
+
+    private static Tree mst = new Tree();
+    private static int totalWeight;
+
+    public BoruvkaMST(Graph graph) {
+        DisjointSet dSet = new DisjointSet(graph.getNodes());
+
+        // repeat at most log N times or until we have N-1 edges
+        for (int t = 1; t < graph.getNodes() && mst.getEdgeCount() < graph.getNodes() - 1; t = t + t) {
+
+            // foreach tree in forest, find closest edge
+            Edge[] closestEdgeArray = new Edge[graph.getNodes()];
+            for (Edge edge : graph.getAllEdges()) {
+                int first = edge.getFirst();
+                int second = edge.getSecond();
+                int firstParent = dSet.getParent(first);
+                int secondParent = dSet.getParent(second);
+                if (firstParent == secondParent) {
+                    continue; // same tree
+                }
+                if (closestEdgeArray[firstParent] == null || edge.getWeight() < closestEdgeArray[firstParent].getWeight()) {
+                    closestEdgeArray[firstParent] = edge;
+                }
+                if (closestEdgeArray[secondParent] == null || edge.getWeight() < closestEdgeArray[secondParent].getWeight()) {
+                    closestEdgeArray[secondParent] = edge;
+                }
+            }
+
+            // add newly discovered edges to MST
+            for (int i = 0; i < graph.getNodes(); i++) {
+                Edge edge = closestEdgeArray[i];
+                if (edge != null) {
+                    int first = edge.getFirst();
+                    int second = edge.getSecond();
+                    // don't add the same edge twice
+                    if (dSet.getParent(first) != dSet.getParent(second)) {
+                        mst.addEdge(edge);
+                        totalWeight += edge.getWeight();
+                        dSet.union(first, second);
+                    }
+                }
+            }
+        }
+    }
+
+    public Iterable<Edge> getMST() {
+        return mst;
+    }
+
+    public int getTotalWeight() {
+        return totalWeight;
+    }
+
+    public String toString() {
+        return "MST: " + mst.toString() + " | Total Weight: " + totalWeight;
+    }
+
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/boruvka/DisjointSet.java

@@ -0,0 +1,49 @@
+package com.baeldung.algorithms.boruvka;
+
+import java.util.Arrays;
+
+public class DisjointSet {
+
+    private int[] nodeParents;
+    private int[] nodeRanks;
+
+    public DisjointSet(int n) {
+        nodeParents = new int[n];
+        nodeRanks = new int[n];
+        for (int i = 0; i < n; i++) {
+            nodeParents[i] = i;
+            nodeRanks[i] = 0;
+        }
+    }
+
+    public int getParent(int node) {
+        while (node != nodeParents[node]) {
+            node = nodeParents[node];
+        }
+        return node;
+    }
+
+    public void union(int node1, int node2) {
+        int node1Parent = getParent(node1);
+        int node2Parent = getParent(node2);
+        if (node1Parent == node2Parent) {
+            return;
+        }
+
+        if (nodeRanks[node1Parent] < nodeRanks[node2Parent]) {
+            nodeParents[node1Parent] = node2Parent;
+        }
+        else if (nodeRanks[node1Parent] > nodeRanks[node2Parent]) {
+            nodeParents[node2Parent] = node1Parent;
+        }
+        else {
+            nodeParents[node2Parent] = node1Parent;
+            nodeRanks[node1Parent]++;
+        }
+    }
+
+    public String toString() {
+        return "Parent: " + Arrays.toString(nodeParents) + "Rank: " + Arrays.toString(nodeRanks);
+    }
+
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/boruvka/Edge.java

@@ -0,0 +1,40 @@
+package com.baeldung.algorithms.boruvka;
+
+public class Edge {
+
+    private final int first;
+    private final int second;
+    private final int weight;
+
+    public Edge(int first, int second, int weight) {
+        this.first = first;
+        this.second = second;
+        this.weight = weight;
+    }
+
+    public double getWeight() {
+        return weight;
+    }
+
+    public int getFirst() {
+        return first;
+    }
+    
+    public int getSecond() {
+        return second;
+    }
+
+    public int getOtherNode(int firstNode) {
+        int secondNode = 0;
+        if (firstNode == first)
+            secondNode = second;
+        else if (firstNode == second)
+            secondNode = first;
+        return secondNode;
+    }
+
+    public String toString() {
+        return String.format("%d-%d %d", first, second, weight);
+    }
+
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/boruvka/Graph.java

@@ -0,0 +1,64 @@
+package com.baeldung.algorithms.boruvka;
+
+import java.io.IOException;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+
+public class Graph {
+
+    private int nodes;
+    private int edges;
+    private Tree[] trees;
+
+    public Graph(Input jsonGraph) throws JsonParseException, JsonMappingException, IOException {
+        nodes = jsonGraph.getNodes();
+        trees = (Tree[]) new Tree[nodes];
+        for (int i = 0; i < nodes; i++) {
+            trees[i] = new Tree();
+        }
+
+        int edgesFromInput = jsonGraph.getEdges();
+        for (int i = 0; i < edgesFromInput; i++) {
+            int first = jsonGraph.getEdgeList()
+                .get(i)
+                .getFirst();
+            int second = jsonGraph.getEdgeList()
+                .get(i)
+                .getSecond();
+            int weight = jsonGraph.getEdgeList()
+                .get(i)
+                .getWeight();
+            Edge edge = new Edge(first, second, weight);
+            
+            trees[first].addEdge(edge);
+            trees[second].addEdge(edge);
+            edges++;
+        }
+
+    }
+
+    public int getNodes() {
+        return nodes;
+    }
+
+    public int getEdges() {
+        return edges;
+    }
+
+    public Iterable<Edge> iterableTree(int i) {
+        return trees[i];
+    }
+
+    public Iterable<Edge> getAllEdges() {
+        Iterable<Edge> list = new Tree();
+        for (int i = 0; i < nodes; i++) {
+            for (Edge edge : iterableTree(i)) {
+                if (edge.getOtherNode(i) > i) {
+                    ((Tree) list).addEdge(edge);
+                }
+            }
+        }
+        return list;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/boruvka/Input.java

@@ -0,0 +1,65 @@
+package com.baeldung.algorithms.boruvka;
+
+import java.util.List;
+
+public class Input {
+    private int nodes;
+    private int edges;
+    private List<E> edgeList;
+
+    public int getNodes() {
+        return nodes;
+    }
+
+    public void setNodes(int nodes) {
+        this.nodes = nodes;
+    }
+
+    public int getEdges() {
+        return edges;
+    }
+
+    public void setEdges(int edges) {
+        this.edges = edges;
+    }
+
+    public List<E> getEdgeList() {
+        return edgeList;
+    }
+
+    public void setEdgeList(List<E> edgeList) {
+        this.edgeList = edgeList;
+    }
+
+    static class E {
+        private int first;
+        private int second;
+        private int weight;
+
+        public int getFirst() {
+            return first;
+        }
+
+        public void setFirst(int first) {
+            this.first = first;
+        }
+
+        public int getSecond() {
+            return second;
+        }
+
+        public void setSecond(int second) {
+            this.second = second;
+        }
+
+        public int getWeight() {
+            return weight;
+        }
+
+        public void setWeight(int weight) {
+            this.weight = weight;
+        }
+
+    }
+
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/boruvka/Tree.java

@@ -0,0 +1,63 @@
+package com.baeldung.algorithms.boruvka;
+
+import java.util.Iterator;
+
+public class Tree implements Iterable<Edge> {
+    private Node root;
+    private int edgeCount;
+
+    private static class Node {
+        private Edge edge;
+        private Node next;
+
+        public String toString() {
+            String nextStr = next != null ? next.toString() : "";
+            return edge.toString() + " | " + nextStr;
+        }
+    }
+
+    public Tree() {
+        root = null;
+        edgeCount = 0;
+    }
+
+    public int getEdgeCount() {
+        return edgeCount;
+    }
+
+    public void addEdge(Edge edge) {
+        Node oldRoot = root;
+        root = new Node();
+        root.edge = edge;
+        root.next = oldRoot;
+        edgeCount++;
+    }
+
+    public String toString() {
+        String rootStr = root != null ? root.toString() : "";
+        return "Tree: " + rootStr + "Size: " + edgeCount;
+    }
+
+    public Iterator<Edge> iterator() {
+        return new LinkedIterator(root);
+    }
+
+    private class LinkedIterator implements Iterator<Edge> {
+        private Node current;
+
+        public LinkedIterator(Node root) {
+            current = root;
+        }
+
+        public boolean hasNext() {
+            return current != null;
+        }
+
+        public Edge next() {
+            Edge edge = current.edge;
+            current = current.next;
+            return edge;
+        }
+    }
+
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/balancedbrackets/BalancedBracketsUsingDequeUnitTest.java

@@ -0,0 +1,76 @@
+package com.baeldung.algorithms.balancedbrackets;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class BalancedBracketsUsingDequeUnitTest {
+    private BalancedBracketsUsingDeque balancedBracketsUsingDeque;
+
+    @Before
+    public void setup() {
+        balancedBracketsUsingDeque = new BalancedBracketsUsingDeque();
+    }
+
+    @Test
+    public void givenNullInput_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced(null);
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEmptyString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenInvalidCharacterString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("abc[](){}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenOddLengthString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{[]()}}}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{[]()}}}}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthUnbalancedString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{[(])}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{[()]}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{[[(())]]}}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenAnotherBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{([])}}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenUnBalancedString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{)[](}}");
+        assertThat(result).isFalse();
+    }
+
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/balancedbrackets/BalancedBracketsUsingStringUnitTest.java

@@ -0,0 +1,76 @@
+package com.baeldung.algorithms.balancedbrackets;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class BalancedBracketsUsingStringUnitTest {
+    private BalancedBracketsUsingString balancedBracketsUsingString;
+
+    @Before
+    public void setup() {
+        balancedBracketsUsingString = new BalancedBracketsUsingString();
+    }
+
+    @Test
+    public void givenNullInput_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced(null);
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEmptyString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingString.isBalanced("");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenInvalidCharacterString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("abc[](){}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenOddLengthString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{[]()}}}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{[]()}}}}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthUnbalancedString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("{[(])}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingString.isBalanced("{[()]}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{[[(())]]}}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenAnotherBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{([])}}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenUnBalancedString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{)[](}}");
+        assertThat(result).isFalse();
+    }
+
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/boruvka/BoruvkaUnitTest.java

@@ -0,0 +1,48 @@
+package com.baeldung.algorithms.boruvka;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+public class BoruvkaUnitTest {
+
+    private Input input;
+    private static String INPUT_JSON = "/input.json";
+
+    @Before
+    public void convertInputJsonToObject() throws JsonParseException, JsonMappingException, IOException {
+        ObjectMapper mapper = new ObjectMapper();
+        StringBuilder jsonStr = new StringBuilder();
+        try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(BoruvkaMST.class.getResourceAsStream(INPUT_JSON)))) {
+            String line;
+            while ((line = bufferedReader.readLine()) != null) {
+                jsonStr.append(line)
+                    .append("\n");
+            }
+        }
+
+        input = mapper.readValue(jsonStr.toString(), Input.class);
+
+    }
+
+    @Test
+    public void givenInputGraph_whenBoruvkaPerformed_thenMinimumSpanningTree() throws JsonParseException, JsonMappingException, IOException {
+        Graph graph = new Graph(input);
+        BoruvkaMST boruvkaMST = new BoruvkaMST(graph);
+
+        Tree mst = (Tree) boruvkaMST.getMST();
+
+        assertEquals(30, boruvkaMST.getTotalWeight());
+        assertEquals(4, mst.getEdgeCount());
+    }
+
+}

algorithms-miscellaneous-5/src/test/resources/input.json

@@ -0,0 +1,41 @@
+{
+	"nodes": 5,
+	"edges": 7,
+	"edgeList": [
+		{
+			"first": 0,
+			"second": 1,
+			"weight": 8
+		},
+		{
+			"first": 0,
+			"second": 2,
+			"weight": 5
+		},
+		{
+			"first": 1,
+			"second": 2,
+			"weight": 9
+		},
+		{
+			"first": 1,
+			"second": 3,
+			"weight": 11
+		},
+		{
+			"first": 2,
+			"second": 3,
+			"weight": 15
+		},
+		{
+			"first": 2,
+			"second": 4,
+			"weight": 10
+		},
+		{
+			"first": 3,
+			"second": 4,
+			"weight": 7
+		}
+	]
+}

algorithms-searching/src/main/java/com/baeldung/algorithms/suffixtree/Node.java

@@ -0,0 +1,57 @@
+package com.baeldung.algorithms.suffixtree;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Node {
+    private String text;
+    private List<Node> children;
+    private int position;
+
+    public Node(String word, int position) {
+        this.text = word;
+        this.position = position;
+        this.children = new ArrayList<>();
+    }
+
+    public String getText() {
+        return text;
+    }
+
+    public void setText(String text) {
+        this.text = text;
+    }
+
+    public int getPosition() {
+        return position;
+    }
+
+    public void setPosition(int position) {
+        this.position = position;
+    }
+
+    public List<Node> getChildren() {
+        return children;
+    }
+
+    public void setChildren(List<Node> children) {
+        this.children = children;
+    }
+
+    public String printTree(String depthIndicator) {
+        String str = "";
+        String positionStr = position > -1 ? "[" + String.valueOf(position) + "]" : "";
+        str += depthIndicator + text + positionStr + "\n";
+
+        for (int i = 0; i < children.size(); i++) {
+            str += children.get(i)
+                .printTree(depthIndicator + "\t");
+        }
+        return str;
+    }
+
+    @Override
+    public String toString() {
+        return printTree("");
+    }
+}

algorithms-searching/src/main/java/com/baeldung/algorithms/suffixtree/SuffixTree.java

@@ -0,0 +1,175 @@
+package com.baeldung.algorithms.suffixtree;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class SuffixTree {
+    private static final Logger LOGGER = LoggerFactory.getLogger(SuffixTree.class);
+    private static final String WORD_TERMINATION = "$";
+    private static final int POSITION_UNDEFINED = -1;
+    private Node root;
+    private String fullText;
+
+    public SuffixTree(String text) {
+        root = new Node("", POSITION_UNDEFINED);
+        for (int i = 0; i < text.length(); i++) {
+            addSuffix(text.substring(i) + WORD_TERMINATION, i);
+        }
+        fullText = text;
+    }
+
+    public List<String> searchText(String pattern) {
+        LOGGER.info("Searching for pattern \"{}\"", pattern);
+        List<String> result = new ArrayList<>();
+        List<Node> nodes = getAllNodesInTraversePath(pattern, root, false);
+
+        if (nodes.size() > 0) {
+            Node lastNode = nodes.get(nodes.size() - 1);
+            if (lastNode != null) {
+                List<Integer> positions = getPositions(lastNode);
+                positions = positions.stream()
+                    .sorted()
+                    .collect(Collectors.toList());
+                positions.forEach(m -> result.add((markPatternInText(m, pattern))));
+            }
+        }
+        return result;
+    }
+
+    private void addSuffix(String suffix, int position) {
+        LOGGER.info(">>>>>>>>>>>> Adding new suffix {}", suffix);
+        List<Node> nodes = getAllNodesInTraversePath(suffix, root, true);
+        if (nodes.size() == 0) {
+            addChildNode(root, suffix, position);
+            LOGGER.info("{}", printTree());
+        } else {
+            Node lastNode = nodes.remove(nodes.size() - 1);
+            String newText = suffix;
+            if (nodes.size() > 0) {
+                String existingSuffixUptoLastNode = nodes.stream()
+                    .map(a -> a.getText())
+                    .reduce("", String::concat);
+
+                // Remove prefix from newText already included in parent
+                newText = newText.substring(existingSuffixUptoLastNode.length());
+            }
+            extendNode(lastNode, newText, position);
+            LOGGER.info("{}", printTree());
+        }
+    }
+
+    private List<Integer> getPositions(Node node) {
+        List<Integer> positions = new ArrayList<>();
+        if (node.getText()
+            .endsWith(WORD_TERMINATION)) {
+            positions.add(node.getPosition());
+        }
+        for (int i = 0; i < node.getChildren()
+            .size(); i++) {
+            positions.addAll(getPositions(node.getChildren()
+                .get(i)));
+        }
+        return positions;
+    }
+
+    private String markPatternInText(Integer startPosition, String pattern) {
+        String matchingTextLHS = fullText.substring(0, startPosition);
+        String matchingText = fullText.substring(startPosition, startPosition + pattern.length());
+        String matchingTextRHS = fullText.substring(startPosition + pattern.length());
+        return matchingTextLHS + "[" + matchingText + "]" + matchingTextRHS;
+    }
+
+    private void addChildNode(Node parentNode, String text, int position) {
+        parentNode.getChildren()
+            .add(new Node(text, position));
+    }
+
+    private void extendNode(Node node, String newText, int position) {
+        String currentText = node.getText();
+        String commonPrefix = getLongestCommonPrefix(currentText, newText);
+
+        if (commonPrefix != currentText) {
+            String parentText = currentText.substring(0, commonPrefix.length());
+            String childText = currentText.substring(commonPrefix.length());
+            splitNodeToParentAndChild(node, parentText, childText);
+        }
+
+        String remainingText = newText.substring(commonPrefix.length());
+        addChildNode(node, remainingText, position);
+    }
+
+    private void splitNodeToParentAndChild(Node parentNode, String parentNewText, String childNewText) {
+        Node childNode = new Node(childNewText, parentNode.getPosition());
+
+        if (parentNode.getChildren()
+            .size() > 0) {
+            while (parentNode.getChildren()
+                .size() > 0) {
+                childNode.getChildren()
+                    .add(parentNode.getChildren()
+                        .remove(0));
+            }
+        }
+
+        parentNode.getChildren()
+            .add(childNode);
+        parentNode.setText(parentNewText);
+        parentNode.setPosition(POSITION_UNDEFINED);
+    }
+
+    private String getLongestCommonPrefix(String str1, String str2) {
+        int compareLength = Math.min(str1.length(), str2.length());
+        for (int i = 0; i < compareLength; i++) {
+            if (str1.charAt(i) != str2.charAt(i)) {
+                return str1.substring(0, i);
+            }
+        }
+        return str1.substring(0, compareLength);
+    }
+
+    private List<Node> getAllNodesInTraversePath(String pattern, Node startNode, boolean isAllowPartialMatch) {
+        List<Node> nodes = new ArrayList<>();
+        for (int i = 0; i < startNode.getChildren()
+            .size(); i++) {
+            Node currentNode = startNode.getChildren()
+                .get(i);
+            String nodeText = currentNode.getText();
+            if (pattern.charAt(0) == nodeText.charAt(0)) {
+                if (isAllowPartialMatch && pattern.length() <= nodeText.length()) {
+                    nodes.add(currentNode);
+                    return nodes;
+                }
+
+                int compareLength = Math.min(nodeText.length(), pattern.length());
+                for (int j = 1; j < compareLength; j++) {
+                    if (pattern.charAt(j) != nodeText.charAt(j)) {
+                        if (isAllowPartialMatch) {
+                            nodes.add(currentNode);
+                        }
+                        return nodes;
+                    }
+                }
+
+                nodes.add(currentNode);
+                if (pattern.length() > compareLength) {
+                    List<Node> nodes2 = getAllNodesInTraversePath(pattern.substring(compareLength), currentNode, isAllowPartialMatch);
+                    if (nodes2.size() > 0) {
+                        nodes.addAll(nodes2);
+                    } else if (!isAllowPartialMatch) {
+                        nodes.add(null);
+                    }
+                }
+                return nodes;
+            }
+        }
+        return nodes;
+    }
+
+    public String printTree() {
+        return root.printTree("");
+    }
+}

algorithms-searching/src/test/java/com/baeldung/algorithms/suffixtree/SuffixTreeUnitTest.java

@@ -0,0 +1,77 @@
+package com.baeldung.algorithms.suffixtree;
+
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class SuffixTreeUnitTest {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(SuffixTreeUnitTest.class);
+
+    private static SuffixTree suffixTree;
+
+    @BeforeClass
+    public static void setUp() {
+        suffixTree = new SuffixTree("havanabanana");
+        printTree();
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForA_thenReturn6Matches() {
+        List<String> matches = suffixTree.searchText("a");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] { "h[a]vanabanana", "hav[a]nabanana", "havan[a]banana", "havanab[a]nana", "havanaban[a]na", "havanabanan[a]" }, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForNab_thenReturn1Match() {
+        List<String> matches = suffixTree.searchText("nab");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] { "hava[nab]anana" }, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForNag_thenReturnNoMatches() {
+        List<String> matches = suffixTree.searchText("nag");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] {}, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForBanana_thenReturn2Matches() {
+        List<String> matches = suffixTree.searchText("ana");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] { "hav[ana]banana", "havanab[ana]na", "havanaban[ana]" }, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForNa_thenReturn4Matches() {
+        List<String> matches = suffixTree.searchText("na");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] { "hava[na]banana", "havanaba[na]na", "havanabana[na]" }, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForX_thenReturnNoMatches() {
+        List<String> matches = suffixTree.searchText("x");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] {}, matches.toArray());
+    }
+
+    private static void printTree() {
+        suffixTree.printTree();
+
+        LOGGER.info("\n" + suffixTree.printTree());
+        LOGGER.info("==============================================");
+    }
+}

algorithms-sorting-2/README.md

@@ -0,0 +1,3 @@
+### Relevant Articles:
+
+- [Partitioning and Sorting Arrays with Many Repeated Entries](https://www.baeldung.com/java-sorting-arrays-with-repeated-entries)

apache-beam/pom.xml

@@ -0,0 +1,43 @@
+<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>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <groupId>com.baeldung.apache</groupId>
+    <artifactId>apache-beam</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.beam</groupId>
+            <artifactId>beam-sdks-java-core</artifactId>
+            <version>${beam.version}</version>
+        </dependency>
+        <!-- runtime scoped -->
+        <dependency>
+            <groupId>org.apache.beam</groupId>
+            <artifactId>beam-runners-direct-java</artifactId>
+            <version>${beam.version}</version>
+            <scope>runtime</scope>
+        </dependency>
+        <!-- test scoped -->
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <beam.version>2.19.0</beam.version>
+        <assertj.version>3.6.1</assertj.version>
+    </properties>
+
+</project>

apache-beam/src/main/java/com/baeldung/apache/beam/intro/WordCount.java

@@ -0,0 +1,71 @@
+package com.baeldung.apache.beam.intro;
+
+import java.util.Arrays;
+
+import org.apache.beam.sdk.Pipeline;
+import org.apache.beam.sdk.io.TextIO;
+import org.apache.beam.sdk.options.PipelineOptions;
+import org.apache.beam.sdk.options.PipelineOptionsFactory;
+import org.apache.beam.sdk.transforms.Count;
+import org.apache.beam.sdk.transforms.Filter;
+import org.apache.beam.sdk.transforms.FlatMapElements;
+import org.apache.beam.sdk.transforms.MapElements;
+import org.apache.beam.sdk.values.KV;
+import org.apache.beam.sdk.values.PCollection;
+import org.apache.beam.sdk.values.TypeDescriptors;
+
+public class WordCount {
+    
+    public static boolean wordCount(String inputFilePath, String outputFilePath) {
+        // We use default options
+        PipelineOptions options = PipelineOptionsFactory.create();
+        // to create the pipeline
+        Pipeline p = Pipeline.create(options);
+        // Here is our workflow graph
+        PCollection<KV<String, Long>> wordCount = p
+            .apply("(1) Read all lines", TextIO.read().from(inputFilePath))
+            .apply("(2) Flatmap to a list of words", FlatMapElements.into(TypeDescriptors.strings())
+                .via(line -> Arrays.asList(line.split("\\s"))))
+            .apply("(3) Lowercase all", MapElements.into(TypeDescriptors.strings())
+                .via(word -> word.toLowerCase()))
+            .apply("(4) Trim punctuations", MapElements.into(TypeDescriptors.strings())
+                .via(word -> trim(word)))
+            .apply("(5) Filter stopwords", Filter.by(word -> !isStopWord(word)))
+            .apply("(6) Count words", Count.perElement());
+        // We convert the PCollection to String so that we can write it to file
+        wordCount.apply(MapElements.into(TypeDescriptors.strings())
+                .via(count -> count.getKey() + " --> " + count.getValue()))
+            .apply(TextIO.write().to(outputFilePath));
+        // Finally we must run the pipeline, otherwise it's only a definition
+        p.run().waitUntilFinish();  
+        return true;
+    }
+    
+    public static boolean isStopWord(String word) {
+        String[] stopwords = {"am", "are", "is", "i", "you", "me",
+                               "he", "she", "they", "them", "was",
+                               "were", "from", "in", "of", "to", "be",
+                               "him", "her", "us", "and", "or"};
+        for (String stopword : stopwords) {
+            if (stopword.compareTo(word) == 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    
+    public static String trim(String word) {
+        return word.replace("(","")
+            .replace(")", "")
+            .replace(",", "")
+            .replace(".", "")
+            .replace("\"", "")
+            .replace("'", "")
+            .replace(":", "")
+            .replace(";", "")
+            .replace("-", "")
+            .replace("?", "")
+            .replace("!", "");
+    }
+
+}

apache-beam/src/test/java/com/baeldung/apache/beam/intro/WordCountUnitTest.java

@@ -0,0 +1,19 @@
+package com.baeldung.apache.beam.intro;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import com.baeldung.apache.beam.intro.WordCount;
+
+public class WordCountUnitTest {
+    
+    @Test
+    // @Ignore
+    public void givenInputFile_whenWordCountRuns_thenJobFinishWithoutError() {
+        boolean jobDone = WordCount.wordCount("src/test/resources/wordcount.txt", "target/output");
+        assertTrue(jobDone);
+    }
+
+}

apache-beam/src/test/resources/wordcount.txt

@@ -0,0 +1,16 @@
+We've all heard the scare stories about North Korea: the homemade nuclear arsenal built while their people starve and then aimed imprecisely at the rest of the world, a 
+leader so deluded he makes L Ron Hubbard look like a man excessively overburdened with self-doubt and their deep-seated belief that foreign capitalists will invade at any 
+moment and steal all their bauxite.
+The popular portrayal of this Marxist nation is something like one of the more harrowing episodes of M*A*S*H, only with the cast of wacky characters replaced by twitchy, 
+heavily armed Stalinist meth addicts
+Cracked would like to take a moment to celebrate the good things about North Korea though, the things that the country's enemies prefer to suppress as part of their politically 
+motivated jealousy. Like how no different to you and me, there's nothing every North Korean likes more after an 18 hour shift at the phosphorus plant than a nice beer to go with 
+his dried fish ration. Ever attentive to its people's needs and in the twinkling of a decade, North Korea's leadership bought, disassembled, transported and rebuilt a British 
+brewery in order to discover and reproduce the secrets of beer and then brew the sweet nectar for its hardworking people, up to 18 bottles at a time. And with minimal fatalities. 
+When was the last time YOUR leader got a beer for YOU, American? (NB do not answer this question if you are Henry Louis Gates).
+Or how about the fried chicken restaurant that downtown Pyongyang boasts? Yes real chicken, fried and then delivered to your sleeping cube, with optional beer if you like! You 
+don't even have to remove the feathers or pull out the gizzard yourself. Mostly. Americans must eat their fried chicken from a bucket, like swine, sold by a company so secretive 
+that even the very blend of seasoning used is intentionally kept from them. And they call North Korea paranoid?
+And how many nations would entertain the syphilitic, bourgeois ramblings of Bill Clinton let alone permit him anywhere near their proud womenfolk? Only wise Kim Jong Il could see 
+past Bill's many, many imperfections and treat him with the pity and kindness he deserves, accepting his feeble pleas to pardon the American spies rightly convicted of photographing 
+the nation's sensitive beetroot fields.

apache-cxf/cxf-aegis/README.md

@@ -1,3 +0,0 @@
-### Relevant Articles
-
-- [Introduction to Apache CXF Aegis Data Binding](https://www.baeldung.com/aegis-data-binding-in-apache-cxf)

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-fop/README.md

@@ -1,5 +0,0 @@
-## Apache FOP
-
-This module contains articles about Apache FOP
-
-### Relevant Articles: 

apache-olingo/olingo2/README.md

@@ -1,4 +1,3 @@
 ### Relevant Articles:
 
-- [OData Protocol Guide](https://www.baeldung.com/odata)
 - [Intro to OData with Olingo](https://www.baeldung.com/olingo)

apache-poi/README.md

@@ -6,3 +6,6 @@ This module contains articles about Apache POI
 - [Microsoft Word Processing in Java with Apache POI](https://www.baeldung.com/java-microsoft-word-with-apache-poi)
 - [Working with Microsoft Excel in Java](https://www.baeldung.com/java-microsoft-excel)
 - [Creating a MS PowerPoint Presentation in Java](https://www.baeldung.com/apache-poi-slideshow)
+- [Merge Cells in Excel Using Apache POI](https://www.baeldung.com/java-apache-poi-merge-cells)
+- [Get String Value of Excel Cell with Apache POI](https://www.baeldung.com/java-apache-poi-cell-string-value)
+- [Read Excel Cell Value Rather Than Formula With Apache POI](https://www.baeldung.com/apache-poi-read-cell-value-formula)

apache-poi/src/test/java/com/baeldung/poi/excel/merge/ExcelCellMergerUnitTest.java

@@ -0,0 +1,53 @@
+package com.baeldung.poi.excel.merge;
+
+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.Sheet;
+import org.apache.poi.ss.usermodel.Workbook;
+import org.apache.poi.ss.util.CellRangeAddress;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+import org.junit.Before;
+import org.junit.Test;
+
+public class ExcelCellMergerUnitTest {
+    private static final String FILE_NAME = "ExcelCellFormatterTest.xlsx";
+    private String fileLocation;
+
+    @Before
+    public void setup() throws IOException, URISyntaxException {
+            fileLocation = Paths.get(ClassLoader.getSystemResource(FILE_NAME).toURI()).toString();
+    }
+
+    @Test
+    public void givenCellIndex_whenAddMergeRegion_thenMergeRegionCreated() throws IOException {
+        Workbook workbook = new XSSFWorkbook(fileLocation);
+        Sheet sheet = workbook.getSheetAt(0);
+
+        assertEquals(0, sheet.getNumMergedRegions());
+        int firstRow = 0; 
+        int lastRow = 0; 
+        int firstCol = 0; 
+        int lastCol = 2;
+        sheet.addMergedRegion(new CellRangeAddress(firstRow, lastRow, firstCol, lastCol));
+        assertEquals(1, sheet.getNumMergedRegions());
+
+        workbook.close();
+    }
+
+    @Test
+    public void givenCellRefString_whenAddMergeRegion_thenMergeRegionCreated() throws IOException {
+        Workbook workbook = new XSSFWorkbook(fileLocation);
+        Sheet sheet = workbook.getSheetAt(0);
+
+        assertEquals(0, sheet.getNumMergedRegions());        
+        sheet.addMergedRegion(CellRangeAddress.valueOf("A1:C1"));
+        assertEquals(1, sheet.getNumMergedRegions());
+
+        workbook.close();
+    }
+
+}

apache-rocketmq/README.md

@@ -3,3 +3,5 @@
 This module contains articles about Apache RocketMQ
 
 ### Relevant Articles: 
+
+- [Apache RocketMQ with Spring Boot](https://www.baeldung.com/apache-rocketmq-spring-boot)

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-spark/README.md

@@ -7,4 +7,4 @@ This module contains articles about Apache Spark
 - [Introduction to Apache Spark](https://www.baeldung.com/apache-spark)
 - [Building a Data Pipeline with Kafka, Spark Streaming and Cassandra](https://www.baeldung.com/kafka-spark-data-pipeline)
 - [Machine Learning with Spark MLlib](https://www.baeldung.com/spark-mlib-machine-learning)
-
+- [Introduction to Spark Graph Processing with GraphFrames](https://www.baeldung.com/spark-graph-graphframes)

apache-tapestry/README.md

@@ -0,0 +1,3 @@
+### Relevant Articles
+
+- [Intro to Apache Tapestry](https://www.baeldung.com/apache-tapestry)

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/README.md

@@ -0,0 +1,3 @@
+### Relevant Articles:
+
+- [AWS S3 with Java – Reactive Support](https://www.baeldung.com/java-aws-s3-reactive)

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>

azure/src/main/resources/application.properties

@@ -5,7 +5,7 @@ spring.jpa.hibernate.ddl-auto=create
 logging.file=azure.log
 logging.level.root=info
 
-spring.datasource.url=jdbc:h2:file:~/test
+spring.datasource.url=jdbc:h2:mem:azure-test-db
 spring.datasource.username=sa
 spring.datasource.password=
 

blade/pom.xml

@@ -106,7 +106,7 @@
                             <arguments>
                                 <argument>java</argument>
                                 <argument>-jar</argument>
-                                <argument>sample-blade-app.jar</argument>
+                                <argument>blade.jar</argument>
                             </arguments>
                         </configuration>
                     </execution>
@@ -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>

cdi/pom.xml

@@ -26,8 +26,8 @@
         </dependency>
         <dependency>
             <groupId>org.hamcrest</groupId>
-            <artifactId>hamcrest-core</artifactId>
+            <artifactId>hamcrest</artifactId>
-            <version>${org.hamcrest.version}</version>
+            <version>${hamcrest.version}</version>
             <scope>test</scope>
         </dependency>
         <dependency>

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>
@@ -77,7 +77,7 @@
                     <dependency>
                         <groupId>org.codehaus.groovy</groupId>
                         <artifactId>groovy-eclipse-compiler</artifactId>
-                        <version>3.3.0-01</version>
+                        <version>${groovy.compiler.version}</version>
                     </dependency>
                     <dependency>
                         <groupId>org.codehaus.groovy</groupId>
@@ -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/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,7 +75,6 @@ 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)
@@ -90,7 +89,6 @@ class WebserviceUnitTest extends GroovyTestCase {
         def words = response.NumberToWordsResponse
         assert words == "one thousand two hundred and thirty four "
     }
-    */
 
     void test_whenConsumingRestGet_thenReceiveResponse() {
         def path = "/get"

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 {
 

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

@@ -13,3 +13,4 @@ This module contains articles about Java 11 core features
 - [Guide to jlink](https://www.baeldung.com/jlink)
 - [Negate a Predicate Method Reference with Java 11](https://www.baeldung.com/java-negate-predicate-method-reference)
 - [Benchmark JDK Collections vs Eclipse Collections](https://www.baeldung.com/jdk-collections-vs-eclipse-collections)
+- [Pre-compile Regex Patterns Into Pattern Objects](https://www.baeldung.com/java-regex-pre-compile)

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>
 
@@ -65,7 +65,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-shade-plugin</artifactId>
-                <version>3.2.1</version>
+                <version>${shade.plugin.version}</version>
                 <executions>
                     <execution>
                         <phase>package</phase>
@@ -108,6 +108,8 @@
         <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>
+        <shade.plugin.version>10.0.0</shade.plugin.version>
     </properties>
 
 </project>

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

@@ -0,0 +1,4 @@
+### Relevant articles:
+
+- [Java Switch Statement](https://www.baeldung.com/java-switch)
+- [New Java 13 Features](https://www.baeldung.com/java-13-new-features)

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/.mvn/jvm.config

@@ -0,0 +1 @@
+--enable-preview

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

@@ -0,0 +1,7 @@
+## Core Java 14
+
+This module contains articles about Java 14. 
+
+### Relevant articles
+
+- [Guide to the @Serial Annotation in Java 14](https://www.baeldung.com/java-14-serial-annotation)

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

@@ -3,9 +3,7 @@
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
-	<groupId>com.baeldung</groupId>
     <artifactId>core-java-14</artifactId>
-	<version>1.0.0-SNAPSHOT</version>
     <name>core-java-14</name>
     <packaging>jar</packaging>
     <url>http://maven.apache.org</url>
@@ -16,7 +14,26 @@
         <version>1.0.0-SNAPSHOT</version>
         <relativePath>../../</relativePath>
     </parent>
-
+    <dependencies>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <version>${junit-jupiter.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>${junit-jupiter.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
     <build>
         <plugins>
             <plugin>
@@ -24,19 +41,14 @@
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>${maven-compiler-plugin.version}</version>
                 <configuration>
-					<source>${maven.compiler.source.version}</source>
+                    <release>${maven.compiler.release}</release>
-					<target>${maven.compiler.target.version}</target>
+                    <compilerArgs>--enable-preview</compilerArgs>
-					<compilerArgs>
-						<compilerArg>
-							--enable-preview
-						</compilerArg>
-					</compilerArgs>
                 </configuration>
             </plugin>
             <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>
@@ -45,8 +57,10 @@
     </build>
 
     <properties>
-		<maven.compiler.source.version>14</maven.compiler.source.version>
+        <maven.compiler.release>14</maven.compiler.release>
-		<maven.compiler.target.version>14</maven.compiler.target.version>
+        <assertj.version>3.6.1</assertj.version>
+        <maven-compiler-plugin.version>3.8.1</maven-compiler-plugin.version>
+        <surefire.plugin.version>3.0.0-M3</surefire.plugin.version>
     </properties>
 
 </project>

core-java-modules/core-java-14/src/main/java/com/baeldung/java14/patternmatchingforinstanceof/PatternMatchingForInstanceOf.java

@@ -0,0 +1,26 @@
+package com.baeldung.java14.patternmatchingforinstanceof;
+
+public class PatternMatchingForInstanceOf {
+
+    public void performAnimalOperations(Animal animal) {
+         if (animal instanceof Cat cat) {
+             cat.meow();
+         } else if(animal instanceof Dog dog) {
+             dog.woof();
+         }
+    }
+
+    abstract class Animal {
+    }
+
+    final class Cat extends Animal {
+        void meow() {
+        }
+    }
+
+    final class Dog extends Animal {
+        void woof() {
+        }
+    }
+
+}

core-java-modules/core-java-14/src/main/java/com/baeldung/java14/textblocks/TextBlocks13.java

@@ -0,0 +1,46 @@
+package com.baeldung.java14.textblocks;
+
+public class TextBlocks13 {
+    public String getBlockOfHtml() {
+        return """
+            <html>
+
+                <body>
+                    <span>example text</span>
+                </body>
+            </html>""";
+    }
+
+    public String getNonStandardIndent() {
+        return """
+                Indent
+            """;
+    }
+
+    public String getQuery() {
+        return """
+            select "id", "user"
+            from "table"
+            """;
+    }
+
+    public String getTextWithCarriageReturns() {
+        return """
+            separated with\r
+            carriage returns""";
+    }
+
+    public String getTextWithEscapes() {
+        return """
+            fun with\n
+            whitespace\t\r
+            and other escapes \"""
+            """;
+    }
+
+    public String getFormattedText(String parameter) {
+        return """
+            Some parameter: %s
+            """.formatted(parameter);
+    }
+}

core-java-modules/core-java-14/src/main/java/com/baeldung/java14/textblocks/TextBlocks14.java

@@ -0,0 +1,16 @@
+package com.baeldung.java14.textblocks;
+
+public class TextBlocks14 {
+    public String getIgnoredNewLines() {
+        return """
+            This is a long test which looks to \
+            have a newline but actually does not""";
+    }
+
+    public String getEscapedSpaces() {
+        return """
+            line 1
+            line 2       \s
+            """;
+    }
+}

core-java-modules/core-java-14/src/test/java/com/baeldung/java14/patternmatchingforinstanceof/PatternMatchingForInstanceOfUnitTest.java

@@ -0,0 +1,33 @@
+package com.baeldung.java14.patternmatchingforinstanceof;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import org.junit.jupiter.api.Test;
+
+import com.baeldung.java14.patternmatchingforinstanceof.PatternMatchingForInstanceOf.Cat;
+import com.baeldung.java14.patternmatchingforinstanceof.PatternMatchingForInstanceOf.Dog;
+
+class PatternMatchingForInstanceOfUnitTest {
+
+    @Test
+    void givenAnAnimal_whenTypeIsCat_ThenCatGoesMeow() {
+        Cat animal = mock(Cat.class);
+
+        PatternMatchingForInstanceOf instanceOf = new PatternMatchingForInstanceOf();
+        instanceOf.performAnimalOperations(animal);
+
+        verify(animal).meow();
+    }
+
+    @Test
+    void givenAnAnimal_whenTypeIsDog_ThenDogGoesWoof() {
+        Dog animal = mock(Dog.class);
+
+        PatternMatchingForInstanceOf instanceOf = new PatternMatchingForInstanceOf();
+        instanceOf.performAnimalOperations(animal);
+
+        verify(animal).woof();
+    }
+
+}

core-java-modules/core-java-14/src/test/java/com/baeldung/java14/textblocks/TextBlocks13UnitTest.java

@@ -0,0 +1,58 @@
+package com.baeldung.java14.textblocks;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class TextBlocks13UnitTest {
+    private TextBlocks13 subject = new TextBlocks13();
+
+    @Test
+    void givenAnOldStyleMultilineString_whenComparing_thenEqualsTextBlock() {
+        String expected = "<html>\n"
+          + "\n"
+          + "    <body>\n"
+          + "        <span>example text</span>\n"
+          + "    </body>\n"
+          + "</html>";
+        assertThat(subject.getBlockOfHtml()).isEqualTo(expected);
+    }
+
+    @Test
+    void givenAnOldStyleString_whenComparing_thenEqualsTextBlock() {
+        String expected = "<html>\n\n    <body>\n        <span>example text</span>\n    </body>\n</html>";
+        assertThat(subject.getBlockOfHtml()).isEqualTo(expected);
+    }
+
+    @Test
+    void givenAnIndentedString_thenMatchesIndentedOldStyle() {
+        assertThat(subject.getNonStandardIndent()).isEqualTo("    Indent\n");
+    }
+
+    @Test
+    void givenAMultilineQuery_thenItCanContainUnescapedQuotes() {
+        assertThat(subject.getQuery()).contains("select \"id\", \"user\"");
+    }
+
+    @Test
+    void givenAMultilineQuery_thenItEndWithANewline() {
+        assertThat(subject.getQuery()).endsWith("\n");
+    }
+
+    @Test
+    void givenATextWithCarriageReturns_thenItContainsBoth() {
+        assertThat(subject.getTextWithCarriageReturns()).isEqualTo("separated with\r\ncarriage returns");
+    }
+
+    @Test
+    void givenAStringWithEscapedWhitespace_thenItAppearsInTheResultingString() {
+        assertThat(subject.getTextWithEscapes()).contains("fun with\n\n")
+            .contains("whitespace\t\r\n")
+            .contains("and other escapes \"\"\"");
+    }
+
+    @Test
+    void givenAFormattedString_thenTheParameterIsReplaced() {
+        assertThat(subject.getFormattedText("parameter")).contains("Some parameter: parameter");
+    }
+}

core-java-modules/core-java-14/src/test/java/com/baeldung/java14/textblocks/TextBlocks14UnitTest.java

@@ -0,0 +1,21 @@
+package com.baeldung.java14.textblocks;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class TextBlocks14UnitTest {
+    private TextBlocks14 subject = new TextBlocks14();
+
+    @Test
+    void givenAStringWithEscapedNewLines_thenTheResultHasNoNewLines() {
+        String expected = "This is a long test which looks to have a newline but actually does not";
+        assertThat(subject.getIgnoredNewLines()).isEqualTo(expected);
+    }
+
+    @Test
+    void givenAStringWithEscapesSpaces_thenTheResultHasLinesEndingWithSpaces() {
+        String expected = "line 1\nline 2        \n";
+        assertThat(subject.getEscapedSpaces()).isEqualTo(expected);
+    }
+}

core-java-modules/core-java-8-2/README.md

@@ -3,7 +3,7 @@
 This module contains articles about Java 8 core features
 
 ### Relevant Articles: 
-- [Anonymous Classes in Java](https://www.baeldung.com/java-anonymous-classes)
+
 - [How to Delay Code Execution in Java](https://www.baeldung.com/java-delay-code-execution)
 - [Run a Java Application from the Command Line](https://www.baeldung.com/java-run-jar-with-arguments)
 - [Java 8 Stream skip() vs limit()](https://www.baeldung.com/java-stream-skip-vs-limit)

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

@@ -48,25 +48,6 @@
                 <filtering>true</filtering>
             </resource>
         </resources>
-
-        <plugins>
-            <plugin>
-                <groupId>org.springframework.boot</groupId>
-                <artifactId>spring-boot-maven-plugin</artifactId>
-                <version>${spring-boot-maven-plugin.version}</version>
-                <executions>
-                    <execution>
-                        <goals>
-                            <goal>repackage</goal>
-                        </goals>
-                        <configuration>
-                            <classifier>spring-boot</classifier>
-                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-        </plugins>
     </build>
 
     <properties>
@@ -74,8 +55,6 @@
         <commons-collections4.version>4.1</commons-collections4.version>
         <!-- testing -->
         <assertj.version>3.6.1</assertj.version>
-        <!-- plugins -->
-        <spring-boot-maven-plugin.version>2.0.4.RELEASE</spring-boot-maven-plugin.version>
     </properties>
 
 </project>

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

@@ -9,6 +9,7 @@ This module contains articles about Java 9 core features
 - [Iterate Through a Range of Dates in Java](https://www.baeldung.com/java-iterate-date-range)
 - [Initialize a HashMap in Java](https://www.baeldung.com/java-initialize-hashmap)
 - [Immutable Set in Java](https://www.baeldung.com/java-immutable-set)
+- [Immutable ArrayList in Java](https://www.baeldung.com/java-immutable-list)
 
 Note: also contains part of the code for the article
 [How to Filter a Collection in Java](https://www.baeldung.com/java-collection-filtering).

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

@@ -37,6 +37,11 @@
             <version>${junit.platform.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-collections4</artifactId>
+            <version>${commons-collections4.version}</version>
+        </dependency>
     </dependencies>
 
     <build>
@@ -69,6 +74,7 @@
         <maven.compiler.source>1.9</maven.compiler.source>
         <maven.compiler.target>1.9</maven.compiler.target>
         <guava.version>25.1-jre</guava.version>
+        <commons-collections4.version>4.1</commons-collections4.version>
     </properties>
 
 </project>

core-java-modules/core-java-9/src/test/java/com/baeldung/java9/list/immutable/ImmutableArrayListUnitTest.java

@@ -1,56 +1,48 @@
-package org.baeldung.java.collections;
+package com.baeldung.java9.list.immutable;
 
 import com.google.common.collect.ImmutableList;
 import org.apache.commons.collections4.ListUtils;
 import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
-public class CoreJavaCollectionsUnitTest {
+public class ImmutableArrayListUnitTest {
-
-    private static final Logger LOG = LoggerFactory.getLogger(CoreJavaCollectionsUnitTest.class);
-
-
-    // tests -
-
-    @Test
-    public final void givenUsingTheJdk_whenArrayListIsSynchronized_thenCorrect() {
-        final List<String> list = new ArrayList<String>(Arrays.asList("one", "two", "three"));
-        final List<String> synchronizedList = Collections.synchronizedList(list);
-        LOG.debug("Synchronized List is: " + synchronizedList);
-    }
 
     @Test(expected = UnsupportedOperationException.class)
-    public final void givenUsingTheJdk_whenUnmodifiableListIsCreatedFromOriginal_thenNoLongerModifiable() {
+    public final void givenUsingTheJdk_whenUnmodifiableListIsCreated_thenNotModifiable() {
-        final List<String> list = new ArrayList<String>(Arrays.asList("one", "two", "three"));
+        final List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
         final List<String> unmodifiableList = Collections.unmodifiableList(list);
         unmodifiableList.add("four");
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public final void givenUsingGuava_whenUnmodifiableListIsCreatedFromOriginal_thenNoLongerModifiable() {
+    public final void givenUsingTheJava9_whenUnmodifiableListIsCreated_thenNotModifiable() {
-        final List<String> list = new ArrayList<String>(Arrays.asList("one", "two", "three"));
+        final List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
+        final List<String> unmodifiableList = List.of(list.toArray(new String[]{}));
+        unmodifiableList.add("four");
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public final void givenUsingGuava_whenUnmodifiableListIsCreated_thenNotModifiable() {
+        final List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
         final List<String> unmodifiableList = ImmutableList.copyOf(list);
         unmodifiableList.add("four");
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public final void givenUsingGuavaBuilder_whenUnmodifiableListIsCreatedFromOriginal_thenNoLongerModifiable() {
+    public final void givenUsingGuavaBuilder_whenUnmodifiableListIsCreated_thenNoLongerModifiable() {
-        final List<String> list = new ArrayList<String>(Arrays.asList("one", "two", "three"));
+        final List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
         final ImmutableList<String> unmodifiableList = ImmutableList.<String>builder().addAll(list).build();
         unmodifiableList.add("four");
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public final void givenUsingCommonsCollections_whenUnmodifiableListIsCreatedFromOriginal_thenNoLongerModifiable() {
+    public final void givenUsingCommonsCollections_whenUnmodifiableListIsCreated_thenNotModifiable() {
-        final List<String> list = new ArrayList<String>(Arrays.asList("one", "two", "three"));
+        final List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
         final List<String> unmodifiableList = ListUtils.unmodifiableList(list);
         unmodifiableList.add("four");
     }
-
 }

core-java-modules/core-java-arrays-2/README.md

@@ -13,4 +13,5 @@ This module contains articles about Java arrays
 - [Removing an Element from an Array in Java](https://www.baeldung.com/java-array-remove-element)
 - [Removing the First Element of an Array](https://www.baeldung.com/java-array-remove-first-element)
 - [Adding an Element to a Java Array vs an ArrayList](https://www.baeldung.com/java-add-element-to-array-vs-list)
+- [Arrays.sort vs Arrays.parallelSort](https://www.baeldung.com/java-arrays-sort-vs-parallelsort)
 - [[<-- Prev]](/core-java-modules/core-java-arrays)

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-2/src/test/java/com/baeldung/arraysort/SortComparisonUnitTest.java

@@ -69,7 +69,7 @@ public class SortComparisonUnitTest {
     }
 
     @Test
-    public void givenArrayOfIntegers_whenUsingArraysSortMethodWithRange_thenSortRangeOfArrayInAscendingOrder() {
+    public void givenArrayOfIntegers_whenUsingArraysSortWithRange_thenSortRangeOfArrayAsc() {
         int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
         int[] expected = { 10, 4, 1, 2, 6, 7, 8, 9, 3, 5 };
 
@@ -89,7 +89,7 @@ public class SortComparisonUnitTest {
     }
 
     @Test
-    public void givenArrayOfIntegers_whenUsingArraysParallelSortMethodWithRange_thenSortRangeOfArrayInAscendingOrder() {
+    public void givenArrayOfIntegers_whenUsingArraysParallelSortWithRange_thenSortRangeOfArrayAsc() {
         int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
         int[] expected = { 10, 4, 1, 2, 6, 7, 8, 9, 3, 5 };
 

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

@@ -0,0 +1,31 @@
+<?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-arrays-3</artifactId>
+	<version>0.1.0-SNAPSHOT</version>
+	<name>core-java-arrays-3</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.assertj</groupId>
+			<artifactId>assertj-core</artifactId>
+			<version>${assertj.version}</version>
+			<scope>test</scope>
+		</dependency>
+	</dependencies>
+
+	<properties>
+		<assertj.version>3.14.0</assertj.version>
+	</properties>
+
+</project>

core-java-modules/core-java-arrays-3/src/test/java/com/baeldung/arrays/deepequals/ArraysDeepEqualsUnitTest.java

@@ -0,0 +1,96 @@
+package com.baeldung.arrays.deepequals;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.Objects;
+import org.junit.jupiter.api.Test;
+
+public class ArraysDeepEqualsUnitTest {
+
+    class Person {
+        private int id;
+        private String name;
+        private int age;
+
+        Person(int id, String name, int age) {
+            this.id = id;
+            this.name = name;
+            this.age = age;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (obj == null) {
+                return false;
+            }
+            if (!(obj instanceof Person))
+                return false;
+            Person person = (Person) obj;
+            return id == person.id && name.equals(person.name) && age == person.age;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(id, name, age);
+        }
+    }
+
+    @Test
+    void givenTwoUnidimensionalObjectTypeArrays_whenUsingEqualsAndDeepEquals_thenBothShouldReturnTrue() {
+        Object[] anArray = new Object[] { "string1", "string2", "string3" };
+        Object[] anotherArray = new Object[] { "string1", "string2", "string3" };
+
+        assertTrue(Arrays.equals(anArray, anotherArray));
+        assertTrue(Arrays.deepEquals(anArray, anotherArray));
+    }
+
+    @Test
+    void givenTwoUnidimensionalObjectTypeArraysWithNullElements_whenUsingEqualsAndDeepEquals_thenBothShouldReturnTrue() {
+        Object[] anArray = new Object[] { "string1", null, "string3" };
+        Object[] anotherArray = new Object[] { "string1", null, "string3" };
+
+        assertTrue(Arrays.equals(anArray, anotherArray));
+        assertTrue(Arrays.deepEquals(anArray, anotherArray));
+    }
+
+    @Test
+    void givenTwoUnidimensionalObjectTypeArraysWithNestedElements_whenUsingEqualsAndDeepEquals_thenShouldReturnDifferently() {
+        Object[] anArray = new Object[] { "string1", null, new String[] { "nestedString1", "nestedString2" } };
+        Object[] anotherArray = new Object[] { "string1", null, new String[] { "nestedString1", "nestedString2" } };
+
+        assertFalse(Arrays.equals(anArray, anotherArray));
+        assertTrue(Arrays.deepEquals(anArray, anotherArray));
+    }
+
+    @Test
+    void givenTwoMultidimensionalPrimitiveTypeArrays_whenUsingEqualsAndDeepEquals_thenBothShouldReturnDifferently() {
+        int[][] anArray = { { 1, 2, 3 }, { 4, 5, 6, 9 }, { 7 } };
+        int[][] anotherArray = { { 1, 2, 3 }, { 4, 5, 6, 9 }, { 7 } };
+
+        assertFalse(Arrays.equals(anArray, anotherArray));
+        assertTrue(Arrays.deepEquals(anArray, anotherArray));
+    }
+
+    @Test
+    void givenTwoMultidimensionalObjectTypeArrays_whenUsingEqualsAndDeepEquals_thenBothShouldReturnDifferently() {
+        Person personArray1[][] = { { new Person(1, "John", 22), new Person(2, "Mike", 23) }, { new Person(3, "Steve", 27), new Person(4, "Gary", 28) } };
+        Person personArray2[][] = { { new Person(1, "John", 22), new Person(2, "Mike", 23) }, { new Person(3, "Steve", 27), new Person(4, "Gary", 28) } };
+
+        assertFalse(Arrays.equals(personArray1, personArray2));
+        assertTrue(Arrays.deepEquals(personArray1, personArray2));
+    }
+
+    @Test
+    void givenTwoMultidimensionalObjectTypeArrays_whenUsingDeepEqualsFromObjectsAndArraysClasses_thenBothShouldReturnTrue() {
+        Person personArray1[][] = { { new Person(1, "John", 22), new Person(2, "Mike", 23) }, { new Person(3, "Steve", 27), new Person(4, "Gary", 28) } };
+        Person personArray2[][] = { { new Person(1, "John", 22), new Person(2, "Mike", 23) }, { new Person(3, "Steve", 27), new Person(4, "Gary", 28) } };
+
+        assertTrue(Objects.deepEquals(personArray1, personArray2));
+        assertTrue(Arrays.deepEquals(personArray1, personArray2));
+    }
+}

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

@@ -66,100 +66,6 @@
                 </executions>
             </plugin>
 
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-jar-plugin</artifactId>
-                <version>${maven-jar-plugin.version}</version>
-                <configuration>
-                    <archive>
-                        <manifest>
-                            <addClasspath>true</addClasspath>
-                            <classpathPrefix>libs/</classpathPrefix>
-                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
-                        </manifest>
-                    </archive>
-                </configuration>
-            </plugin>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-assembly-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>single</goal>
-                        </goals>
-                        <configuration>
-                            <archiveBaseDirectory>${project.basedir}</archiveBaseDirectory>
-                            <archive>
-                                <manifest>
-                                    <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
-                                </manifest>
-                            </archive>
-                            <descriptorRefs>
-                                <descriptorRef>jar-with-dependencies</descriptorRef>
-                            </descriptorRefs>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-shade-plugin</artifactId>
-                <version>${maven-shade-plugin.version}</version>
-                <executions>
-                    <execution>
-                        <goals>
-                            <goal>shade</goal>
-                        </goals>
-                        <configuration>
-                            <shadedArtifactAttached>true</shadedArtifactAttached>
-                            <transformers>
-                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
-                                    <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
-                                </transformer>
-                            </transformers>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-
-            <plugin>
-                <groupId>com.jolira</groupId>
-                <artifactId>onejar-maven-plugin</artifactId>
-                <version>${onejar-maven-plugin.version}</version>
-                <executions>
-                    <execution>
-                        <configuration>
-                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
-                            <attachToBuild>true</attachToBuild>
-                            <filename>${project.build.finalName}-onejar.${project.packaging}</filename>
-                        </configuration>
-                        <goals>
-                            <goal>one-jar</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-
-            <plugin>
-                <groupId>org.springframework.boot</groupId>
-                <artifactId>spring-boot-maven-plugin</artifactId>
-                <version>${spring-boot-maven-plugin.version}</version>
-                <executions>
-                    <execution>
-                        <goals>
-                            <goal>repackage</goal>
-                        </goals>
-                        <configuration>
-                            <classifier>spring-boot</classifier>
-                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
             
             <plugin>
                 <groupId>org.codehaus.mojo</groupId>
@@ -183,8 +89,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>
@@ -250,110 +156,6 @@
             </build>
         </profile>
 
-        <!-- java instrumentation profiles to build jars -->
-        <profile>
-            <id>buildAgentLoader</id>
-            <build>
-                <plugins>
-                    <plugin>
-                        <groupId>org.apache.maven.plugins</groupId>
-                        <artifactId>maven-jar-plugin</artifactId>
-                        <executions>
-                            <execution>
-                                <phase>package</phase>
-                                <goals>
-                                    <goal>jar</goal>
-                                </goals>
-                                <configuration>
-                                    <classifier>agentLoader</classifier>
-                                    <classesDirectory>target/classes</classesDirectory>
-                                    <archive>
-                                        <manifest>
-                                            <addClasspath>true</addClasspath>
-                                        </manifest>
-                                        <manifestFile>${project.build.outputDirectory}/META-INF/MANIFEST.MF</manifestFile>
-                                    </archive>
-
-                                    <includes>
-                                        <include>com/baeldung/instrumentation/application/AgentLoader.class</include>
-                                        <include>com/baeldung/instrumentation/application/Launcher.class</include>
-                                    </includes>
-                                </configuration>
-                            </execution>
-                        </executions>
-                    </plugin>
-                </plugins>
-            </build>
-        </profile>
-        <profile>
-            <id>buildApplication</id>
-            <build>
-                <plugins>
-                    <plugin>
-                        <groupId>org.apache.maven.plugins</groupId>
-                        <artifactId>maven-jar-plugin</artifactId>
-                        <executions>
-                            <execution>
-                                <phase>package</phase>
-                                <goals>
-                                    <goal>jar</goal>
-                                </goals>
-                                <configuration>
-                                    <classifier>application</classifier>
-                                    <classesDirectory>target/classes</classesDirectory>
-                                    <archive>
-                                        <manifest>
-                                            <addClasspath>true</addClasspath>
-                                        </manifest>
-                                        <manifestFile>${project.build.outputDirectory}/META-INF/MANIFEST.MF</manifestFile>
-                                    </archive>
-
-                                    <includes>
-                                        <include>com/baeldung/instrumentation/application/MyAtm.class</include>
-                                        <include>com/baeldung/instrumentation/application/MyAtmApplication.class</include>
-                                        <include>com/baeldung/instrumentation/application/Launcher.class</include>
-                                    </includes>
-                                </configuration>
-                            </execution>
-                        </executions>
-                    </plugin>
-                </plugins>
-            </build>
-        </profile>
-        <profile>
-            <id>buildAgent</id>
-            <build>
-                <plugins>
-                    <plugin>
-                        <groupId>org.apache.maven.plugins</groupId>
-                        <artifactId>maven-jar-plugin</artifactId>
-                        <executions>
-                            <execution>
-                                <phase>package</phase>
-                                <goals>
-                                    <goal>jar</goal>
-                                </goals>
-                                <configuration>
-                                    <classifier>agent</classifier>
-                                    <classesDirectory>target/classes</classesDirectory>
-                                    <archive>
-                                        <manifest>
-                                            <addClasspath>true</addClasspath>
-                                        </manifest>
-                                        <manifestFile>${project.build.outputDirectory}/META-INF/MANIFEST.MF</manifestFile>
-                                    </archive>
-
-                                    <includes>
-                                        <include>com/baeldung/instrumentation/agent/AtmTransformer.class</include>
-                                        <include>com/baeldung/instrumentation/agent/MyInstrumentationAgent.class</include>
-                                    </includes>
-                                </configuration>
-                            </execution>
-                        </executions>
-                    </plugin>
-                </plugins>
-            </build>
-        </profile>
     </profiles>
 
     <properties>
@@ -368,11 +170,9 @@
 
         <!-- maven and spring plugins -->
         <maven-javadoc-plugin.version>3.0.0-M1</maven-javadoc-plugin.version>
-        <maven-jar-plugin.version>3.0.2</maven-jar-plugin.version>
-        <onejar-maven-plugin.version>1.4.4</onejar-maven-plugin.version>
-        <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-arrays/src/main/java/com/baeldung/array/Find2ndLargestInArray.java

@@ -1,20 +0,0 @@
-package com.baeldung.array;
-
-public class Find2ndLargestInArray {
-
-    public static int find2ndLargestElement(int[] array) {
-        int maxElement = array[0];
-        int secondLargestElement = -1;
-
-        for (int index = 0; index < array.length; index++) {
-            if (maxElement <= array[index]) {
-                secondLargestElement = maxElement;
-                maxElement = array[index];
-            } else if (secondLargestElement < array[index]) {
-                secondLargestElement = array[index];
-            }
-        }
-        return secondLargestElement;
-    }
-
-}

core-java-modules/core-java-arrays/src/main/java/com/baeldung/array/FindElementInArray.java

@@ -1,22 +0,0 @@
-package com.baeldung.array;
-
-import java.util.Arrays;
-
-public class FindElementInArray {
-
-    public static boolean findGivenElementInArrayWithoutUsingStream(int[] array, int element) {
-        boolean actualResult = false;
-
-        for (int index = 0; index < array.length; index++) {
-            if (element == array[index]) {
-                actualResult = true;
-                break;
-            }
-        }
-        return actualResult;
-    }
-
-    public static boolean findGivenElementInArrayUsingStream(int[] array, int element) {
-        return Arrays.stream(array).filter(x -> element == x).findFirst().isPresent();
-    }
-}

core-java-modules/core-java-arrays/src/test/java/com/baeldung/array/Find2ndLargestInArrayUnitTest.java

@@ -1,16 +0,0 @@
-package com.baeldung.array;
-
-import org.junit.Assert;
-import org.junit.Test;
-
-public class Find2ndLargestInArrayUnitTest {
-    @Test
-    public void givenAnIntArray_thenFind2ndLargestElement() {
-        int[] array = { 1, 3, 24, 16, 87, 20 };
-        int expected2ndLargest = 24;
-
-        int actualSecondLargestElement = Find2ndLargestInArray.find2ndLargestElement(array);
-
-        Assert.assertEquals(expected2ndLargest, actualSecondLargestElement);
-    }
-}

core-java-modules/core-java-arrays/src/test/java/com/baeldung/array/FindElementInArrayUnitTest.java

@@ -1,35 +0,0 @@
-package com.baeldung.array;
-
-import org.junit.Assert;
-import org.junit.Test;
-
-public class FindElementInArrayUnitTest {
-    @Test
-    public void givenAnIntArray_whenNotUsingStream_thenFindAnElement() {
-        int[] array = { 1, 3, 4, 8, 19, 20 };
-        int element = 19;
-        boolean expectedResult = true;
-        boolean actualResult = FindElementInArray.findGivenElementInArrayWithoutUsingStream(array, element);
-        Assert.assertEquals(expectedResult, actualResult);
-
-        element = 78;
-        expectedResult = false;
-        actualResult = FindElementInArray.findGivenElementInArrayWithoutUsingStream(array, element);
-        Assert.assertEquals(expectedResult, actualResult);
-    }
-
-    @Test
-    public void givenAnIntArray_whenUsingStream_thenFindAnElement() {
-        int[] array = { 15, 16, 12, 18 };
-        int element = 16;
-        boolean expectedResult = true;
-        boolean actualResult = FindElementInArray.findGivenElementInArrayUsingStream(array, element);
-        Assert.assertEquals(expectedResult, actualResult);
-
-        element = 20;
-        expectedResult = false;
-        actualResult = FindElementInArray.findGivenElementInArrayUsingStream(array, element);
-        Assert.assertEquals(expectedResult, actualResult);
-    }
-
-}

core-java-modules/core-java-collections-array-list/README.md

@@ -3,9 +3,8 @@
 This module contains articles about the Java ArrayList collection
 
 ### Relevant Articles: 
-- [Immutable ArrayList in Java](http://www.baeldung.com/java-immutable-list)
+- [Guide to the Java ArrayList](https://www.baeldung.com/java-arraylist)
-- [Guide to the Java ArrayList](http://www.baeldung.com/java-arraylist)
+- [Add Multiple Items to an Java ArrayList](https://www.baeldung.com/java-add-items-array-list)
-- [Add Multiple Items to an Java ArrayList](http://www.baeldung.com/java-add-items-array-list)
 - [ClassCastException: Arrays$ArrayList cannot be cast to ArrayList](https://www.baeldung.com/java-classcastexception-arrays-arraylist)
 - [Multi Dimensional ArrayList in Java](https://www.baeldung.com/java-multi-dimensional-arraylist)
 - [Removing an Element From an ArrayList](https://www.baeldung.com/java-arraylist-remove-element)

core-java-modules/core-java-collections-array-list/src/test/java/com/baeldung/collections/ArrayListUnitTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java.collections;
+package com.baeldung.collections;
 
 import com.google.common.collect.Sets;
 import org.junit.Before;

core-java-modules/core-java-collections-array-list/src/test/java/com/baeldung/collections/CoreJavaCollectionsUnitTest.java

@@ -0,0 +1,25 @@
+package com.baeldung.collections;
+
+import com.google.common.collect.ImmutableList;
+import org.apache.commons.collections4.ListUtils;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class CoreJavaCollectionsUnitTest {
+
+    private static final Logger LOG = LoggerFactory.getLogger(CoreJavaCollectionsUnitTest.class);
+
+    @Test
+    public final void givenUsingTheJdk_whenArrayListIsSynchronized_thenCorrect() {
+        final List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
+        final List<String> synchronizedList = Collections.synchronizedList(list);
+        LOG.debug("Synchronized List is: " + synchronizedList);
+    }
+
+}

core-java-modules/core-java-collections-list-2/README.md

@@ -3,13 +3,13 @@
 This module contains articles about the Java List collection
 
 ### Relevant Articles: 
-- [Check If Two Lists are Equal in Java](http://www.baeldung.com/java-test-a-list-for-ordinality-and-equality)
+- [Check If Two Lists are Equal in Java](https://www.baeldung.com/java-test-a-list-for-ordinality-and-equality)
 - [Java 8 Streams: Find Items From One List Based On Values From Another List](https://www.baeldung.com/java-streams-find-list-items)
-- [A Guide to the Java LinkedList](http://www.baeldung.com/java-linkedlist)
+- [A Guide to the Java LinkedList](https://www.baeldung.com/java-linkedlist)
-- [Java List UnsupportedOperationException](http://www.baeldung.com/java-list-unsupported-operation-exception)
+- [Java List UnsupportedOperationException](https://www.baeldung.com/java-list-unsupported-operation-exception)
 - [Java List Initialization in One Line](https://www.baeldung.com/java-init-list-one-line)
 - [Ways to Iterate Over a List in Java](https://www.baeldung.com/java-iterate-list)
-- [Flattening Nested Collections in Java](http://www.baeldung.com/java-flatten-nested-collections)
+- [Flattening Nested Collections in Java](https://www.baeldung.com/java-flatten-nested-collections)
 - [Intersection of Two Lists in Java](https://www.baeldung.com/java-lists-intersection)
 - [Searching for a String in an ArrayList](https://www.baeldung.com/java-search-string-arraylist)
 - [[<-- Prev]](/core-java-modules/core-java-collections-list)[[Next -->]](/core-java-modules/core-java-collections-list-3)

core-java-modules/core-java-collections-list-2/src/test/java/com/baeldung/java/list/ListAssertJUnitTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java.lists;
+package com.baeldung.java.list;
 
 import org.junit.Test;
 

core-java-modules/core-java-collections-list-2/src/test/java/com/baeldung/java/list/ListJUnitTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java.lists;
+package com.baeldung.java.list;
 
 import org.junit.Assert;
 import org.junit.Test;

core-java-modules/core-java-collections-list-2/src/test/java/com/baeldung/java/list/ListTestNgUnitTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java.lists;
+package com.baeldung.java.list;
 
 import org.junit.Test;
 

core-java-modules/core-java-collections-list-2/src/test/java/org/baeldung/java/lists/README.md

@@ -1,2 +0,0 @@
-### Relevant Articles:
-- [Check If Two Lists are Equal in Java](http://www.baeldung.com/java-test-a-list-for-ordinality-and-equality)

core-java-modules/core-java-collections-list/src/test/java/com/baeldung/collections/JavaCollectionCleanupUnitTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java.collections;
+package com.baeldung.collections;
 
 import static org.hamcrest.Matchers.hasSize;
 import static org.junit.Assert.assertThat;

core-java-modules/core-java-collections-list/src/test/java/com/baeldung/list/random/RandomListElementUnitTest.java

@@ -1,4 +1,4 @@
-package org.baeldung;
+package com.baeldung.list.random;
 
 import com.google.common.collect.Lists;
 import org.junit.Test;

core-java-modules/core-java-concurrency-advanced-2/src/main/java/com/baeldung/threadlocalrandom/ThreadLocalRandomBenchMarkRunner.java

@@ -1,22 +1,27 @@
 package com.baeldung.threadlocalrandom;
 
 import org.openjdk.jmh.runner.Runner;
-import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.ChainedOptionsBuilder;
 import org.openjdk.jmh.runner.options.OptionsBuilder;
 
+import com.google.common.collect.ImmutableList;
+
 public class ThreadLocalRandomBenchMarkRunner {
 
     public static void main(String[] args) throws Exception {
 
-        Options options = new OptionsBuilder().include(ThreadLocalRandomBenchMarker.class.getSimpleName())
+        ChainedOptionsBuilder options = new OptionsBuilder().include(ThreadLocalRandomBenchMarker.class.getSimpleName())
-            .threads(1)
             .forks(1)
             .shouldFailOnError(true)
             .shouldDoGC(true)
-            .jvmArgs("-server")
+            .jvmArgs("-server");
-            .build();
-
-        new Runner(options).run();
 
+        for (Integer i : ImmutableList.of(1, 2, 8, 32)) {
+            new Runner(
+                    options
+                            .threads(i)
+                            .build())
+                    .run();
+        }
     }
 }

core-java-modules/core-java-concurrency-advanced-2/src/main/java/com/baeldung/threadlocalrandom/ThreadLocalRandomBenchMarker.java

@@ -1,64 +1,34 @@
 package com.baeldung.threadlocalrandom;
 
-import java.util.ArrayList;
-import java.util.List;
 import java.util.Random;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.TimeUnit;
 
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
-import org.openjdk.jmh.annotations.Level;
 import org.openjdk.jmh.annotations.Mode;
 import org.openjdk.jmh.annotations.OutputTimeUnit;
 import org.openjdk.jmh.annotations.Scope;
-import org.openjdk.jmh.annotations.Setup;
 import org.openjdk.jmh.annotations.State;
 import org.openjdk.jmh.annotations.Warmup;
 
-@BenchmarkMode(Mode.AverageTime)
+@BenchmarkMode(Mode.Throughput)
 @Warmup(iterations = 1)
 @OutputTimeUnit(TimeUnit.MICROSECONDS)
 @State(Scope.Benchmark)
 public class ThreadLocalRandomBenchMarker {
+    private final Random random = new Random();
 
-    List<Callable<Integer>> randomCallables = new ArrayList<>();
+    @Benchmark
-    List<Callable<Integer>> threadLocalRandomCallables = new ArrayList<>();
+    public int randomValuesUsingRandom() {
-
-    @Setup(Level.Iteration)
-    public void init() {
-        Random random = new Random();
-        randomCallables = new ArrayList<>();
-        threadLocalRandomCallables = new ArrayList<>();
-        for (int i = 0; i < 1000; i++) {
-            randomCallables.add(() -> {
         return random.nextInt();
-            });
     }
 
-        for (int i = 0; i < 1000; i++) {
+    @Benchmark
-            threadLocalRandomCallables.add(() -> {
+    public int randomValuesUsingThreadLocalRandom() {
-                return ThreadLocalRandom.current()
+        return ThreadLocalRandom
+                .current()
                 .nextInt();
-            });
-        }
-    }
-
-    @Benchmark
-    public void randomValuesUsingRandom() throws InterruptedException {
-        ExecutorService executor = Executors.newWorkStealingPool();
-        executor.invokeAll(randomCallables);
-        executor.shutdown();
-    }
-
-    @Benchmark
-    public void randomValuesUsingThreadLocalRandom() throws InterruptedException {
-        ExecutorService executor = Executors.newWorkStealingPool();
-        executor.invokeAll(threadLocalRandomCallables);
-        executor.shutdown();
     }
 
 }

core-java-modules/core-java-concurrency-advanced-3/README.md

@@ -8,4 +8,6 @@ This module contains articles about advanced topics about multithreading with co
 
 - [Common Concurrency Pitfalls in Java](https://www.baeldung.com/java-common-concurrency-pitfalls)
 - [Guide to RejectedExecutionHandler](https://www.baeldung.com/java-rejectedexecutionhandler)
-[[<-- previous]](/core-java-modules/core-java-concurrency-advanced-2)
+- [Guide to Work Stealing in Java](https://www.baeldung.com/java-work-stealing)
+- [Asynchronous Programming in Java](https://www.baeldung.com/java-asynchronous-programming)
+- [[<-- previous]](/core-java-modules/core-java-concurrency-advanced-2)

core-java-modules/core-java-concurrency-advanced-3/src/main/java/com/baeldung/workstealing/PrimeNumbers.java

@@ -0,0 +1,85 @@
+package com.baeldung.workstealing;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ForkJoinTask;
+import java.util.concurrent.RecursiveAction;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class PrimeNumbers extends RecursiveAction {
+
+    private int lowerBound;
+    private int upperBound;
+    private int granularity;
+    static final List<Integer> GRANULARITIES
+      = Arrays.asList(1, 10, 100, 1000, 10000);
+    private AtomicInteger noOfPrimeNumbers;
+
+    PrimeNumbers(int lowerBound, int upperBound, int granularity, AtomicInteger noOfPrimeNumbers) {
+        this.lowerBound = lowerBound;
+        this.upperBound = upperBound;
+        this.granularity = granularity;
+        this.noOfPrimeNumbers = noOfPrimeNumbers;
+    }
+
+    PrimeNumbers(int upperBound) {
+        this(1, upperBound, 100, new AtomicInteger(0));
+    }
+
+    private PrimeNumbers(int lowerBound, int upperBound, AtomicInteger noOfPrimeNumbers) {
+        this(lowerBound, upperBound, 100, noOfPrimeNumbers);
+    }
+
+    private List<PrimeNumbers> subTasks() {
+        List<PrimeNumbers> subTasks = new ArrayList<>();
+
+        for (int i = 1; i <= this.upperBound / granularity; i++) {
+            int upper = i * granularity;
+            int lower = (upper - granularity) + 1;
+            subTasks.add(new PrimeNumbers(lower, upper, noOfPrimeNumbers));
+        }
+        return subTasks;
+    }
+
+    @Override
+    protected void compute() {
+        if (((upperBound + 1) - lowerBound) > granularity) {
+            ForkJoinTask.invokeAll(subTasks());
+        } else {
+            findPrimeNumbers();
+        }
+    }
+
+    void findPrimeNumbers() {
+        for (int num = lowerBound; num <= upperBound; num++) {
+            if (isPrime(num)) {
+                noOfPrimeNumbers.getAndIncrement();
+            }
+        }
+    }
+
+    private boolean isPrime(int number) {
+        if (number == 2) {
+            return true;
+        }
+
+        if (number == 1 || number % 2 == 0) {
+            return false;
+        }
+
+        int noOfNaturalNumbers = 0;
+
+        for (int i = 1; i <= number; i++) {
+            if (number % i == 0) {
+                noOfNaturalNumbers++;
+            }
+        }
+
+        return noOfNaturalNumbers == 2;
+    }
+
+    public int noOfPrimeNumbers() {
+        return noOfPrimeNumbers.intValue();
+    }
+}

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,24 +29,26 @@ public class SaturationPolicyUnitTest {
         }
     }
 
+    @Ignore
     @Test
     public void givenAbortPolicy_WhenSaturated_ThenShouldThrowRejectedExecutionException() {
         executor = new ThreadPoolExecutor(1, 1, 0, MILLISECONDS, new SynchronousQueue<>(), new AbortPolicy());
-        executor.execute(() -> waitFor(100));
+        executor.execute(() -> waitFor(250));
 
         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());
-        executor.execute(() -> waitFor(100));
+        executor.execute(() -> waitFor(250));
 
-        long startTime = System.nanoTime();
+        long startTime = System.currentTimeMillis();
-        executor.execute(() -> waitFor(100));
+        executor.execute(() -> waitFor(500));
-        double blockedDuration = (System.nanoTime() - startTime) / 1_000_000.0;
+        long blockedDuration = System.currentTimeMillis() - startTime;
 
-        assertThat(blockedDuration).isGreaterThanOrEqualTo(100);
+        assertThat(blockedDuration).isGreaterThanOrEqualTo(500);
     }
 
     @Test

core-java-modules/core-java-concurrency-advanced-3/src/test/java/com/baeldung/workstealing/PrimeNumbersUnitManualTest.java

@@ -0,0 +1,101 @@
+package com.baeldung.workstealing;
+
+import org.junit.Test;
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.RunnerException;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Logger;
+
+import static org.junit.Assert.fail;
+
+public class PrimeNumbersUnitManualTest {
+
+    private static Logger logger = Logger.getAnonymousLogger();
+
+    @Test
+    public void givenPrimesCalculated_whenUsingPoolsAndOneThread_thenOneThreadSlowest() {
+        Options opt = new OptionsBuilder()
+          .include(Benchmarker.class.getSimpleName())
+          .forks(1)
+          .build();
+
+        try {
+            new Runner(opt).run();
+        } catch (RunnerException e) {
+            fail();
+        }
+    }
+
+    @Test
+    public void givenNewWorkStealingPool_whenGettingPrimes_thenStealCountChanges() {
+        StringBuilder info = new StringBuilder();
+
+        for (int granularity : PrimeNumbers.GRANULARITIES) {
+            int parallelism = ForkJoinPool.getCommonPoolParallelism();
+            ForkJoinPool pool =
+              (ForkJoinPool) Executors.newWorkStealingPool(parallelism);
+
+            stealCountInfo(info, granularity, pool);
+        }
+        logger.info("\nExecutors.newWorkStealingPool ->" + info.toString());
+    }
+
+    @Test
+    public void givenCommonPool_whenGettingPrimes_thenStealCountChangesSlowly() {
+        StringBuilder info = new StringBuilder();
+
+        for (int granularity : PrimeNumbers.GRANULARITIES) {
+            ForkJoinPool pool = ForkJoinPool.commonPool();
+            stealCountInfo(info, granularity, pool);
+        }
+        logger.info("\nForkJoinPool.commonPool ->" + info.toString());
+    }
+
+    private void stealCountInfo(StringBuilder info, int granularity, ForkJoinPool forkJoinPool) {
+        PrimeNumbers primes = new PrimeNumbers(1, 10000, granularity, new AtomicInteger(0));
+        forkJoinPool.invoke(primes);
+        forkJoinPool.shutdown();
+
+        long steals = forkJoinPool.getStealCount();
+        String output = "\nGranularity: [" + granularity + "], Steals: [" + steals + "]";
+        info.append(output);
+    }
+
+
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.MILLISECONDS)
+    @State(Scope.Benchmark)
+    @Fork(value = 2, warmups = 1, jvmArgs = {"-Xms2G", "-Xmx2G"})
+    public static class Benchmarker {
+
+        @Benchmark
+        public void singleThread() {
+            PrimeNumbers primes = new PrimeNumbers(10000);
+            primes.findPrimeNumbers(); // get prime numbers using a single thread
+        }
+
+        @Benchmark
+        public void commonPoolBenchmark() {
+            PrimeNumbers primes = new PrimeNumbers(10000);
+            ForkJoinPool pool = ForkJoinPool.commonPool();
+            pool.invoke(primes);
+            pool.shutdown();
+        }
+
+        @Benchmark
+        public void newWorkStealingPoolBenchmark() {
+            PrimeNumbers primes = new PrimeNumbers(10000);
+            int parallelism = ForkJoinPool.getCommonPoolParallelism();
+            ForkJoinPool stealer = (ForkJoinPool) Executors.newWorkStealingPool(parallelism);
+            stealer.invoke(primes);
+            stealer.shutdown();
+        }
+    }
+}

core-java-modules/core-java-concurrency-advanced/src/main/java/com/baeldung/concurrent/volatilekeyword/SharedObject.java

@@ -4,7 +4,7 @@ package com.baeldung.concurrent.volatilekeyword;
 public class SharedObject {
     private volatile int count=0;
 
-    void increamentCount(){
+    void incrementCount(){
         count++;
     }
     public int  getCount(){

core-java-modules/core-java-concurrency-advanced/src/test/java/com/baeldung/concurrent/volatilekeyword/SharedObjectManualTest.java

@@ -10,7 +10,7 @@ public class SharedObjectManualTest {
     public void whenOneThreadWrites_thenVolatileReadsFromMainMemory() throws InterruptedException {
         SharedObject sharedObject = new SharedObject();
 
-        Thread writer = new Thread(() -> sharedObject.increamentCount());
+        Thread writer = new Thread(() -> sharedObject.incrementCount());
         writer.start();
         Thread.sleep(100);
 
@@ -31,11 +31,11 @@ public class SharedObjectManualTest {
     @Test
     public void whenTwoThreadWrites_thenVolatileReadsFromMainMemory() throws InterruptedException {
         SharedObject sharedObject = new SharedObject();
-        Thread writerOne = new Thread(() -> sharedObject.increamentCount());
+        Thread writerOne = new Thread(() -> sharedObject.incrementCount());
         writerOne.start();
         Thread.sleep(100);
 
-        Thread writerTwo = new Thread(() -> sharedObject.increamentCount());
+        Thread writerTwo = new Thread(() -> sharedObject.incrementCount());
         writerTwo.start();
         Thread.sleep(100);
 

core-java-modules/core-java-concurrency-collections/src/test/java/com/baeldung/java/stream/ThreadPoolInParallelStreamIntegrationTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java.streams;
+package com.baeldung.java.stream;
 
 import org.junit.Test;
 

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

@@ -6,4 +6,5 @@ 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)
+- [How to Set the JVM Time Zone](https://www.baeldung.com/java-jvm-time-zone)
 - [[<-- Prev]](/core-java-modules/core-java-date-operations-1)

core-java-modules/core-java-date-operations-2/src/test/java/com/baeldung/offsetdatetime/ConvertToOffsetDateTimeUnitTest.java

@@ -4,6 +4,7 @@ import org.junit.Test;
 
 import java.time.OffsetDateTime;
 import java.util.Date;
+import java.util.TimeZone;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
@@ -18,12 +19,19 @@ public class ConvertToOffsetDateTimeUnitTest {
 
     @Test
     public void givenDate_whenHasOffset_thenConvertWithOffset() {
+        TimeZone prevTimezone = TimeZone.getDefault();
+        TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
+
         Date date = new Date();
         date.setHours(6);
         date.setMinutes(30);
+
         OffsetDateTime odt = ConvertToOffsetDateTime.convert(date, 3, 30);
         assertEquals(10, odt.getHour());
         assertEquals(0, odt.getMinute());
+
+        // Reset the timezone to its original value to prevent side effects
+        TimeZone.setDefault(prevTimezone);
     }
 
 }