Merge https://github.com/eugenp/tutorials

2020-03-24 17:58:54 +01:00
parent 81acf67d71 060557608c
commit 9fe2ea2d71
488 changed files with 11596 additions and 1955 deletions
@@ -73,8 +73,6 @@ ninja/devDb.mv.db
 **/out-tsc
 **/nbproject/
 **/nb-configuration.xml
 core-scala/.cache-main
 core-scala/.cache-tests
 persistence-modules/hibernate5/transaction.log
@@ -22,10 +22,38 @@ This project is **a collection of small and focused tutorials** - each covering
 A strong focus of these is, of course, the Spring Framework - Spring, Spring Boot and Spring Security. 
 In additional to Spring, the modules here are covering a number of aspects in Java. 
 Profile based segregation
 ====================
 We are using maven build profiles to segregate the huge list of individual projects we have in our repository.
 The projects are broadly divided into 3 list: first, second and heavy. 
 Next, they are segregated further on the basis of tests that we want to execute.
 Therefore, we have a total of 6 profiles:
 | Profile                 | Includes                    | Type of test enabled |
 | ----------------------- | --------------------------- | -------------------- |
 | default-first           | First set of projects       | *UnitTest            |
 | integration-lite-first  | First set of projects       | *IntegrationTest     |
 | default-second          | Second set of projects      | *UnitTest            |
 | integration-lite-second | Second set of projects      | *IntegrationTest     |
 | default-heavy           | Heavy/long running projects | *UnitTest            |
 | integration-heavy       | Heavy/long running projects | *IntegrationTest     |
 Building the project
 ====================
-To do the full build, do: `mvn clean install`
+
 Though it should not be needed often to build the entire repository at once because we are usually concerned with a specific module.
 But if we want to, we can invoke the below command from the root of the repository if we want to build the entire repository with only Unit Tests enabled:
 `mvn clean install -Pdefault-first,default-second,default-heavy`
 or if we want to build the entire repository with Integration Tests enabled, we can do:
 `mvn clean install -Pintegration-lite-first,integration-lite-second,integration-heavy`
 Building a single module
@@ -46,8 +74,18 @@ When you're working with an individual module, there's no need to import all of
 Running Tests
 =============
-The command `mvn clean install` will run the unit tests in a module.
+The command `mvn clean install` from within a module will run the unit tests in that module.
-To run the integration tests, use the command `mvn clean install -Pintegration-lite-first`
+For Spring modules this will also run the `SpringContextTest` if present.
 To run the integration tests, use the command:
 `mvn clean install -Pintegration-lite-first` or 
 `mvn clean install -Pintegration-lite-second` or 
 `mvn clean install -Pintegration-heavy`
 depending on the list where our module exists
@@ -41,11 +41,6 @@
            <artifactId>guava</artifactId>
            <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>
@@ -78,7 +73,6 @@
        <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>
@@ -1,61 +0,0 @@
 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;
    }
 }
@@ -1,49 +0,0 @@
 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);
    }
 }
@@ -1,40 +0,0 @@
 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);
    }
 }
@@ -1,64 +0,0 @@
 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;
    }
 }
@@ -1,65 +0,0 @@
 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;
        }
    }
 }
@@ -1,63 +0,0 @@
 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;
        }
    }
 }
@@ -1,48 +0,0 @@
 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());
    }
 }
@@ -0,0 +1,27 @@
 <?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>algorithms-miscellaneous-6</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>algorithms-miscellaneous-6</name>
    <parent>
        <groupId>com.baeldung</groupId>
        <artifactId>parent-modules</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    <dependencies>
    <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>${guava.version}</version>
        </dependency>
    </dependencies>
    <properties>
        <guava.version>28.1-jre</guava.version>
    </properties>
 </project>
@@ -0,0 +1,84 @@
 package com.baeldung.algorithms.boruvka;
 import com.google.common.graph.EndpointPair;
 import com.google.common.graph.MutableValueGraph;
 import com.google.common.graph.ValueGraphBuilder;
 public class BoruvkaMST {
    private static MutableValueGraph<Integer, Integer> mst = ValueGraphBuilder.undirected()
        .build();
    private static int totalWeight;
    public BoruvkaMST(MutableValueGraph<Integer, Integer> graph) {
        int size = graph.nodes().size();
        UnionFind uf = new UnionFind(size);
        // repeat at most log N times or until we have N-1 edges
        for (int t = 1; t < size && mst.edges().size() < size - 1; t = t + t) {
            EndpointPair<Integer>[] closestEdgeArray = new EndpointPair[size];
            // foreach tree in graph, find closest edge
            for (EndpointPair<Integer> edge : graph.edges()) {
                int u = edge.nodeU();
                int v = edge.nodeV();
                int uParent = uf.find(u);
                int vParent = uf.find(v);
                if (uParent == vParent) {
                    continue; // same tree
                }
                int weight = graph.edgeValueOrDefault(u, v, 0);
                if (closestEdgeArray[uParent] == null) {
                    closestEdgeArray[uParent] = edge;
                }
                if (closestEdgeArray[vParent] == null) {
                    closestEdgeArray[vParent] = edge;
                }
                int uParentWeight = graph.edgeValueOrDefault(closestEdgeArray[uParent].nodeU(), closestEdgeArray[uParent].nodeV(), 0);
                int vParentWeight = graph.edgeValueOrDefault(closestEdgeArray[vParent].nodeU(), closestEdgeArray[vParent].nodeV(), 0);
                if (weight < uParentWeight) {
                    closestEdgeArray[uParent] = edge;
                }
                if (weight < vParentWeight) {
                    closestEdgeArray[vParent] = edge;
                }
            }
            // add newly discovered edges to MST
            for (int i = 0; i < size; i++) {
                EndpointPair<Integer> edge = closestEdgeArray[i];
                if (edge != null) {
                    int u = edge.nodeU();
                    int v = edge.nodeV();
                    int weight = graph.edgeValueOrDefault(u, v, 0);
                    // don't add the same edge twice
                    if (uf.find(u) != uf.find(v)) {
                        mst.putEdgeValue(u, v, weight);
                        totalWeight += weight;
                        uf.union(u, v);
                    }
                }
            }
        }
    }
    public MutableValueGraph<Integer, Integer> getMST() {
        return mst;
    }
    public int getTotalWeight() {
        return totalWeight;
    }
    public String toString() {
        return "MST: " + mst.toString() + " | Total Weight: " + totalWeight;
    }
 }
@@ -0,0 +1,39 @@
 package com.baeldung.algorithms.boruvka;
 public class UnionFind {
    private int[] parents;
    private int[] ranks;
    public UnionFind(int n) {
        parents = new int[n];
        ranks = new int[n];
        for (int i = 0; i < n; i++) {
            parents[i] = i;
            ranks[i] = 0;
        }
    }
    public int find(int u) {
        while (u != parents[u]) {
            u = parents[u];
        }
        return u;
    }
    public void union(int u, int v) {
        int uParent = find(u);
        int vParent = find(v);
        if (uParent == vParent) {
            return;
        }
        if (ranks[uParent] < ranks[vParent]) {
            parents[uParent] = vParent;
        } else if (ranks[uParent] > ranks[vParent]) {
            parents[vParent] = uParent;
        } else {
            parents[vParent] = uParent;
            ranks[uParent]++;
        }
    }
 }
@@ -0,0 +1,33 @@
 package com.baeldung.algorithms.gradientdescent;
 import java.util.function.Function;
 public class GradientDescent {
    private final double precision = 0.000001;
    public double findLocalMinimum(Function<Double, Double> f, double initialX) {
        double stepCoefficient = 0.1;
        double previousStep = 1.0;
        double currentX = initialX;
        double previousX = initialX;
        double previousY = f.apply(previousX);
        int iter = 100;
        currentX += stepCoefficient * previousY;
        while (previousStep > precision && iter > 0) {
            iter--;
            double currentY = f.apply(currentX);
            if (currentY > previousY) {
                stepCoefficient = -stepCoefficient / 2;
            }
            previousX = currentX;
            currentX += stepCoefficient * previousY;
            previousY = currentY;
            previousStep = StrictMath.abs(currentX - previousX);
        }
        return currentX;
    }
 }
@@ -0,0 +1,37 @@
 package com.baeldung.algorithms.boruvka;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import org.junit.Before;
 import org.junit.Test;
 import com.google.common.graph.MutableValueGraph;
 import com.google.common.graph.ValueGraphBuilder;
 public class BoruvkaUnitTest {
    private MutableValueGraph<Integer, Integer> graph;
    @Before
    public void setup() {
        graph = ValueGraphBuilder.undirected()
            .build();
        graph.putEdgeValue(0, 1, 8);
        graph.putEdgeValue(0, 2, 5);
        graph.putEdgeValue(1, 2, 9);
        graph.putEdgeValue(1, 3, 11);
        graph.putEdgeValue(2, 3, 15);
        graph.putEdgeValue(2, 4, 10);
        graph.putEdgeValue(3, 4, 7);
    }
    @Test
    public void givenInputGraph_whenBoruvkaPerformed_thenMinimumSpanningTree() {
        BoruvkaMST boruvkaMST = new BoruvkaMST(graph);
        MutableValueGraph<Integer, Integer> mst = boruvkaMST.getMST();
        assertEquals(30, boruvkaMST.getTotalWeight());
        assertEquals(4, mst.edges().size());
    }
 }
@@ -0,0 +1,20 @@
 package com.baeldung.algorithms.gradientdescent;
 import static org.junit.Assert.assertTrue;
 import java.util.function.Function;
 import org.junit.Test;
 public class GradientDescentUnitTest {
    @Test
    public void givenFunction_whenStartingPointIsOne_thenLocalMinimumIsFound() {
        Function<Double, Double> df = x ->
            StrictMath.abs(StrictMath.pow(x, 3)) - (3 * StrictMath.pow(x, 2)) + x;
        GradientDescent gd = new GradientDescent();
        double res = gd.findLocalMinimum(df, 1);
        assertTrue(res > 1.78);
        assertTrue(res < 1.84);
    }
 }
@@ -16,12 +16,6 @@
    <name>aws-reactive</name>
    <description>AWS Reactive Sample</description>
    <properties>
        <java.version>1.8</java.version>
        <spring.version>2.2.1.RELEASE</spring.version>
        <awssdk.version>2.10.27</awssdk.version>
    </properties>
    <dependencyManagement>
        <dependencies>
@@ -105,4 +99,9 @@
        </plugins>
    </build>
    <properties>
        <java.version>1.8</java.version>
        <spring.version>2.2.1.RELEASE</spring.version>
        <awssdk.version>2.10.27</awssdk.version>
    </properties>
 </project>
@@ -0,0 +1,189 @@
 package com.baeldung.concurrent.atomic;
 import java.util.concurrent.atomic.AtomicMarkableReference;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 public class AtomicMarkableReferenceUnitTest {
    class Employee {
        private int id;
        private String name;
        Employee(int id, String name) {
            this.id = id;
            this.name = name;
        }
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    }
    @Test
    void givenMarkValueAsTrue_whenUsingIsMarkedMethod_thenMarkValueShouldBeTrue() {
        Employee employee = new Employee(123, "Mike");
        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(employee, true);
        Assertions.assertTrue(employeeNode.isMarked());
    }
    @Test
    void givenMarkValueAsFalse_whenUsingIsMarkedMethod_thenMarkValueShouldBeFalse() {
        Employee employee = new Employee(123, "Mike");
        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(employee, false);
        Assertions.assertFalse(employeeNode.isMarked());
    }
    @Test
    void whenUsingGetReferenceMethod_thenCurrentReferenceShouldBeReturned() {
        Employee employee = new Employee(123, "Mike");
        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(employee, true);
        Assertions.assertEquals(employee, employeeNode.getReference());
    }
    @Test
    void whenUsingGetMethod_thenCurrentReferenceAndMarkShouldBeReturned() {
        Employee employee = new Employee(123, "Mike");
        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(employee, true);
        boolean[] markHolder = new boolean[1];
        Employee currentEmployee = employeeNode.get(markHolder);
        Assertions.assertEquals(employee, currentEmployee);
        Assertions.assertTrue(markHolder[0]);
    }
    @Test
    void givenNewReferenceAndMark_whenUsingSetMethod_thenCurrentReferenceAndMarkShouldBeUpdated() {
        Employee employee = new Employee(123, "Mike");
        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(employee, true);
        Employee newEmployee = new Employee(124, "John");
        employeeNode.set(newEmployee, false);
        Assertions.assertEquals(newEmployee, employeeNode.getReference());
        Assertions.assertFalse(employeeNode.isMarked());
    }
    @Test
    void givenTheSameObjectReference_whenUsingAttemptMarkMethod_thenMarkShouldBeUpdated() {
        Employee employee = new Employee(123, "Mike");
        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(employee, true);
        Assertions.assertTrue(employeeNode.attemptMark(employee, false));
        Assertions.assertFalse(employeeNode.isMarked());
    }
    @Test
    void givenDifferentObjectReference_whenUsingAttemptMarkMethod_thenMarkShouldNotBeUpdated() {
        Employee employee = new Employee(123, "Mike");
        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(employee, true);
        Employee expectedEmployee = new Employee(123, "Mike");
        Assertions.assertFalse(employeeNode.attemptMark(expectedEmployee, false));
        Assertions.assertTrue(employeeNode.isMarked());
    }
    @Test
    void givenCurrentReferenceAndCurrentMark_whenUsingCompareAndSet_thenReferenceAndMarkShouldBeUpdated() {
        Employee employee = new Employee(123, "Mike");
        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(employee, true);
        Employee newEmployee = new Employee(124, "John");
        Assertions.assertTrue(employeeNode.compareAndSet(employee, newEmployee, true, false));
        Assertions.assertEquals(newEmployee, employeeNode.getReference());
        Assertions.assertFalse(employeeNode.isMarked());
    }
    @Test
    void givenNotCurrentReferenceAndCurrentMark_whenUsingCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() {
        Employee employee = new Employee(123, "Mike");
        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(employee, true);
        Employee newEmployee = new Employee(124, "John");
        Assertions.assertFalse(employeeNode.compareAndSet(new Employee(1234, "Steve"), newEmployee, true, false));
        Assertions.assertEquals(employee, employeeNode.getReference());
        Assertions.assertTrue(employeeNode.isMarked());
    }
    @Test
    void givenCurrentReferenceAndNotCurrentMark_whenUsingCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() {
        Employee employee = new Employee(123, "Mike");
        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(employee, true);
        Employee newEmployee = new Employee(124, "John");
        Assertions.assertFalse(employeeNode.compareAndSet(employee, newEmployee, false, true));
        Assertions.assertEquals(employee, employeeNode.getReference());
        Assertions.assertTrue(employeeNode.isMarked());
    }
    @Test
    void givenNotCurrentReferenceAndNotCurrentMark_whenUsingCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() {
        Employee employee = new Employee(123, "Mike");
        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(employee, true);
        Employee newEmployee = new Employee(124, "John");
        Assertions.assertFalse(employeeNode.compareAndSet(new Employee(1234, "Steve"), newEmployee, false, true));
        Assertions.assertEquals(employee, employeeNode.getReference());
        Assertions.assertTrue(employeeNode.isMarked());
    }
    @Test
    void givenCurrentReferenceAndCurrentMark_whenUsingWeakCompareAndSet_thenReferenceAndMarkShouldBeUpdated() {
        Employee employee = new Employee(123, "Mike");
        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(employee, true);
        Employee newEmployee = new Employee(124, "John");
        Assertions.assertTrue(employeeNode.weakCompareAndSet(employee, newEmployee, true, false));
        Assertions.assertEquals(newEmployee, employeeNode.getReference());
        Assertions.assertFalse(employeeNode.isMarked());
    }
    @Test
    void givenNotCurrentReferenceAndCurrentMark_whenUsingWeakCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() {
        Employee employee = new Employee(123, "Mike");
        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(employee, true);
        Employee newEmployee = new Employee(124, "John");
        Assertions.assertFalse(employeeNode.weakCompareAndSet(new Employee(1234, "Steve"), newEmployee, true, false));
        Assertions.assertEquals(employee, employeeNode.getReference());
        Assertions.assertTrue(employeeNode.isMarked());
    }
    @Test
    void givenCurrentReferenceAndNotCurrentMark_whenUsingWeakCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() {
        Employee employee = new Employee(123, "Mike");
        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(employee, true);
        Employee newEmployee = new Employee(124, "John");
        Assertions.assertFalse(employeeNode.weakCompareAndSet(employee, newEmployee, false, true));
        Assertions.assertEquals(employee, employeeNode.getReference());
        Assertions.assertTrue(employeeNode.isMarked());
    }
    @Test
    void givenNotCurrentReferenceAndNotCurrentMark_whenUsingWeakCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() {
        Employee employee = new Employee(123, "Mike");
        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(employee, true);
        Employee newEmployee = new Employee(124, "John");
        Assertions.assertFalse(employeeNode.weakCompareAndSet(new Employee(1234, "Steve"), newEmployee, false, true));
        Assertions.assertEquals(employee, employeeNode.getReference());
        Assertions.assertTrue(employeeNode.isMarked());
    }
 }
@@ -1,43 +1,47 @@
-<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">
+<project
-  <modelVersion>4.0.0</modelVersion>
+    xmlns="http://maven.apache.org/POM/4.0.0"
-  <groupId>com.baeldung.concurrent.lock</groupId>
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  <artifactId>core-java-concurrency-collections-2</artifactId>
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-  <version>0.0.1-SNAPSHOT</version>
+    <modelVersion>4.0.0</modelVersion>
    <groupId>com.baeldung.concurrent.lock</groupId>
    <artifactId>core-java-concurrency-collections-2</artifactId>
    <version>0.0.1-SNAPSHOT</version>
-  <properties>
+    <dependencies>
-      <jmh.version>1.21</jmh.version>
+        <dependency>
-      <guava.version>28.2-jre</guava.version>
+            <groupId>com.google.guava</groupId>
-  </properties>
+            <artifactId>guava</artifactId>
            <version>${guava.version}</version>
        </dependency>
        <dependency>
            <groupId>org.openjdk.jmh</groupId>
            <artifactId>jmh-core</artifactId>
            <version>${jmh.version}</version>
        </dependency>
        <dependency>
            <groupId>org.openjdk.jmh</groupId>
            <artifactId>jmh-generator-annprocess</artifactId>
            <version>${jmh.version}</version>
        </dependency>
-  <dependencies>
+    </dependencies>
-    <dependency>
+    <build>
-        <groupId>com.google.guava</groupId>
+        <sourceDirectory>src</sourceDirectory>
-        <artifactId>guava</artifactId>
+        <plugins>
-        <version>${guava.version}</version>
+            <plugin>
-    </dependency>    
+                <artifactId>maven-compiler-plugin</artifactId>
-    <dependency>
+                <version>3.8.0</version>
-        <groupId>org.openjdk.jmh</groupId>
+                <configuration>
-        <artifactId>jmh-core</artifactId>
+                    <source>1.8</source>
-        <version>${jmh.version}</version>
+                    <target>1.8</target>
-    </dependency>
+                </configuration>
-    <dependency>
+            </plugin>
-        <groupId>org.openjdk.jmh</groupId>
+        </plugins>
-        <artifactId>jmh-generator-annprocess</artifactId>
+    </build>
-        <version>${jmh.version}</version>
+
-    </dependency>
+    <properties>
        <jmh.version>1.21</jmh.version>
        <guava.version>28.2-jre</guava.version>
    </properties>
  </dependencies>
  <build>
    <sourceDirectory>src</sourceDirectory>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.0</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
 </project>
@@ -0,0 +1,35 @@
 package com.baeldung.datetime.dayofweek;
 import java.text.DateFormat;
 import java.text.SimpleDateFormat;
 import java.time.DayOfWeek;
 import java.time.LocalDate;
 import java.time.format.TextStyle;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.Locale;
 public class DayOfWeekExtractor {
    public static int getDayNumberOld(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal.get(Calendar.DAY_OF_WEEK);
    }
    public static String getDayStringOld(Date date, Locale locale ) {
        DateFormat formatter = new SimpleDateFormat("EEEE", locale);
        return formatter.format(date);
    }
    public static int getDayNumberNew(LocalDate date) {
        DayOfWeek day = date.getDayOfWeek();
        return day.getValue();
    }
    public static String getDayStringNew(LocalDate date, Locale locale ) {
        DayOfWeek day = date.getDayOfWeek();
        return day.getDisplayName(TextStyle.FULL, locale);
    }
 }
@@ -0,0 +1,52 @@
 package com.baeldung.datetime.dayofweek;
 import static org.assertj.core.api.Assertions.assertThat;
 import java.text.DateFormat;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.time.LocalDate;
 import java.util.Calendar;
 import java.util.Locale;
 import org.junit.Test;
 public class DayOfWeekExtractorUnitTest {
    private DateFormat oldDateParser = new SimpleDateFormat("yyyy-MM-dd"); 
    @Test
    public void givenFeb29_2020_thenOldSaturdayNumber() throws ParseException {
        assertThat(DayOfWeekExtractor.getDayNumberOld(oldDateParser.parse("2020-02-29")) == Calendar.SATURDAY);
    }
    @Test
    public void givenFeb29_2020_and_localeUS_thenOldSaturdayText() throws ParseException {
        assertThat("Saturday".equals(DayOfWeekExtractor.getDayStringOld(oldDateParser.parse("2020-02-29"), Locale.US)) );
    }
    @Test
    public void givenFeb29_2020_and_localeDE_thenOldSaturdayText() throws ParseException {
        assertThat("Samstag".equals(DayOfWeekExtractor.getDayStringOld(oldDateParser.parse("2020-02-29"), Locale.GERMANY)) );
    }
    @Test
    public void givenFeb29_2020_thenNewSaturdayNumber() throws ParseException {
        assertThat(DayOfWeekExtractor.getDayNumberNew(LocalDate.parse("2020-02-29")) == Calendar.SATURDAY);
    }
    @Test
    public void givenFeb29_2020_and_localeUS_thenNewSaturdayText() throws ParseException {
        assertThat("Saturday".equals(DayOfWeekExtractor.getDayStringOld(oldDateParser.parse("2020-02-29"), Locale.US)) );
    }
    @Test
    public void givenFeb29_2020_and_localeDE_thenNewSaturdayText() throws ParseException {
        assertThat("Samstag".equals(DayOfWeekExtractor.getDayStringOld(oldDateParser.parse("2020-02-29"), Locale.GERMANY)) );
    }
 }
@@ -64,6 +64,11 @@
            <artifactId>jmh-generator-annprocess</artifactId>
            <version>${jmh-generator.version}</version>
        </dependency>
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>${commons-codec.version}</version>
        </dependency>
        <dependency>
            <groupId>org.assertj</groupId>
@@ -113,6 +118,7 @@
        <hibernate-validator.version>6.0.2.Final</hibernate-validator.version>
        <javax.el-api.version>3.0.0</javax.el-api.version>
        <javax.el.version>2.2.6</javax.el.version>
        <commons-codec.version>1.14</commons-codec.version>
    </properties>
 </project>
@@ -1,6 +1,8 @@
 <?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"
+<project
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.baeldung.core-kotlin-modules</groupId>
    <artifactId>core-kotlin-modules</artifactId>
@@ -1,8 +0,0 @@
 ## Core Scala
 This module contains articles about Scala's core features
 ### Relevant Articles: 
 - [Introduction to Scala](https://www.baeldung.com/scala-intro)
 - [Regular Expressions in Scala](https://www.baeldung.com/scala/regular-expressions)
@@ -1,6 +1,8 @@
 <?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"
+<project
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    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-scala</artifactId>
    <version>1.0-SNAPSHOT</version>
@@ -51,5 +53,5 @@
        <scala.version>2.12.7</scala.version>
        <scala.plugin.version>3.3.2</scala.plugin.version>
    </properties>
 </project>
 </project>
@@ -1,44 +0,0 @@
 package com.baeldung.scala
 /**
 * Sample code demonstrating the various control structured.
 *
 * @author Chandra Prakash
 *
 */
 object ControlStructuresDemo {
  def gcd(x : Int, y : Int) : Int = {
    if (y == 0) x else gcd(y, x % y)
  }
  def gcdIter(x : Int, y : Int) : Int = {
    var a = x
    var b = y
    while (b > 0) {
      a = a % b
      val t = a
      a = b
      b = t
    }
    a
  }
  def rangeSum(a : Int, b : Int) = {
    var sum = 0;
    for (i <- a to b) {
      sum += i
    }
    sum
  }
  def factorial(a : Int) : Int = {
    var result = 1;
    var i = 1;
    do {
      result *= i
      i = i + 1
    } while (i <= a)
    result
  }
 }
@@ -1,27 +0,0 @@
 package com.baeldung.scala
 /**
 * Sample Code demonstrating a class.
 *
 * @author Chandra Prakash
 *
 */
 class Employee(val name : String,
               var salary : Int,
               annualIncrement : Int = 20) {
  def incrementSalary() : Unit = {
    salary += annualIncrement
  }
  override def toString =
    s"Employee(name=$name, salary=$salary)"
 }
 /**
 * A Trait which will make the toString return upper case value.
 */
 trait UpperCasePrinter {
  override def toString: String = super.toString toUpperCase
 }
@@ -1,6 +0,0 @@
 package com.baeldung.scala
 object HelloWorld extends App {
  println("Hello World!")
  args foreach println
 }
--- a/Show More
+++ b/Show More