Merge remote-tracking branch 'upstream/master'

2017-10-03 05:29:33 +02:00 · 2017-10-03 05:29:33 +02:00 · ddcbc36203
commit ddcbc36203
parent 239da95f3d 9aa221afbc
1311 changed files with 35720 additions and 3412 deletions
--- a/.gitignore
+++ b/.gitignore
@ -41,3 +41,5 @@ SpringDataInjectionDemo/.mvn/wrapper/maven-wrapper.properties
 spring-call-getters-using-reflection/.mvn/wrapper/maven-wrapper.properties

 spring-check-if-a-property-is-null/.mvn/wrapper/maven-wrapper.properties
+*.springBeans
+
--- a/README.md
+++ b/README.md
@ -23,4 +23,4 @@ Any IDE can be used to work with the projects, but if you're using Eclipse, cons

 CI - Jenkins
 ================================
-This tutorials project is being built **[>> HERE](https://rest-security.ci.cloudbees.com/job/tutorials/)**
+This tutorials project is being built **[>> HERE](https://rest-security.ci.cloudbees.com/job/github%20projects%20Jobs/job/tutorials/)**
--- a/algorithms/README.md
+++ b/algorithms/README.md
@ -8,3 +8,4 @@
 - [Check If a Number Is Prime in Java](http://www.baeldung.com/java-prime-numbers)
 - [Example of Hill Climbing Algorithm](http://www.baeldung.com/java-hill-climbing-algorithm)
 - [Monte Carlo Tree Search for Tic-Tac-Toe Game](http://www.baeldung.com/java-monte-carlo-tree-search)
+- [String Search Algorithms for Large Texts](http://www.baeldung.com/java-full-text-search-algorithms)
--- a/algorithms/pom.xml
+++ b/algorithms/pom.xml
@ -34,6 +34,11 @@
            <artifactId>jenetics</artifactId>
            <version>3.7.0</version>
        </dependency>
+        <dependency>
+            <groupId>org.jgrapht</groupId>
+            <artifactId>jgrapht-core</artifactId>
+            <version>1.0.1</version>
+        </dependency>
    </dependencies>

    <build>
--- a/algorithms/src/main/java/com/baeldung/algorithms/binarysearch/BinarySearch.java
+++ b/algorithms/src/main/java/com/baeldung/algorithms/binarysearch/BinarySearch.java
@ -0,0 +1,55 @@
+package com.baeldung.algorithms.binarysearch;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class BinarySearch {
+
+    public int runBinarySearchIteratively(int[] sortedArray, int key, int low, int high) {
+
+        int index = Integer.MAX_VALUE;
+
+        while (low <= high) {
+
+            int mid = (low + high) / 2;
+
+            if (sortedArray[mid] < key) {
+                low = mid + 1;
+            } else if (sortedArray[mid] > key) {
+                high = mid - 1;
+            } else if (sortedArray[mid] == key) {
+                index = mid;
+                break;
+            }
+        }
+        return index;
+    }
+
+    public int runBinarySearchRecursively(int[] sortedArray, int key, int low, int high) {
+
+        int middle = (low + high) / 2;
+        if (high < low) {
+            return -1;
+        }
+
+        if (key == sortedArray[middle]) {
+          return middle;
+        } else if (key < sortedArray[middle]) {
+          return runBinarySearchRecursively(sortedArray, key, low, middle - 1);
+        } else {
+          return runBinarySearchRecursively(sortedArray, key, middle + 1, high);
+        }
+    }
+
+    public int runBinarySearchUsingJavaArrays(int[] sortedArray, Integer key) {
+        int index = Arrays.binarySearch(sortedArray, key);
+        return index;
+    }
+
+    public int runBinarySearchUsingJavaCollections(List<Integer> sortedList, Integer key) {
+        int index = Collections.binarySearch(sortedList, key);
+        return index;
+    }
+
+}
--- a/algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionBruteForce.java
+++ b/algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionBruteForce.java
@ -0,0 +1,38 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleDetectionBruteForce {
+
+    public static <T> CycleDetectionResult<T> detectCycle(Node<T> head) {
+        if (head == null) {
+            return new CycleDetectionResult<>(false, null);
+        }
+
+        Node<T> it1 = head;
+        int nodesTraversedByOuter = 0;
+        while (it1 != null && it1.next != null) {
+            it1 = it1.next;
+            nodesTraversedByOuter++;
+
+            int x = nodesTraversedByOuter;
+            Node<T> it2 = head;
+            int noOfTimesCurrentNodeVisited = 0;
+
+            while (x > 0) {
+                it2 = it2.next;
+
+                if (it2 == it1) {
+                    noOfTimesCurrentNodeVisited++;
+                }
+
+                if (noOfTimesCurrentNodeVisited == 2) {
+                    return new CycleDetectionResult<>(true, it1);
+                }
+
+                x--;
+            }
+        }
+
+        return new CycleDetectionResult<>(false, null);
+    }
+
+}
--- a/algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionByFastAndSlowIterators.java
+++ b/algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionByFastAndSlowIterators.java
@ -0,0 +1,25 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleDetectionByFastAndSlowIterators {
+
+    public static <T> CycleDetectionResult<T> detectCycle(Node<T> head) {
+        if (head == null) {
+            return new CycleDetectionResult<>(false, null);
+        }
+
+        Node<T> slow = head;
+        Node<T> fast = head;
+
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+
+            if (slow == fast) {
+                return new CycleDetectionResult<>(true, fast);
+            }
+        }
+
+        return new CycleDetectionResult<>(false, null);
+    }
+
+}
--- a/algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionByHashing.java
+++ b/algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionByHashing.java
@ -0,0 +1,27 @@
+package com.baeldung.algorithms.linkedlist;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class CycleDetectionByHashing {
+
+    public static <T> CycleDetectionResult<T> detectCycle(Node<T> head) {
+        if (head == null) {
+            return new CycleDetectionResult<>(false, null);
+        }
+
+        Set<Node<T>> set = new HashSet<>();
+        Node<T> node = head;
+
+        while (node != null) {
+            if (set.contains(node)) {
+                return new CycleDetectionResult<>(true, node);
+            }
+            set.add(node);
+            node = node.next;
+        }
+
+        return new CycleDetectionResult<>(false, null);
+    }
+
+}
--- a/algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionResult.java
+++ b/algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionResult.java
@ -0,0 +1,12 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleDetectionResult<T> {
+    boolean cycleExists;
+    Node<T> node;
+
+    public CycleDetectionResult(boolean cycleExists, Node<T> node) {
+        super();
+        this.cycleExists = cycleExists;
+        this.node = node;
+    }
+}
--- a/algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleRemovalBruteForce.java
+++ b/algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleRemovalBruteForce.java
@ -0,0 +1,56 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleRemovalBruteForce {
+
+    public static <T> boolean detectAndRemoveCycle(Node<T> head) {
+        CycleDetectionResult<T> result = CycleDetectionByFastAndSlowIterators.detectCycle(head);
+
+        if (result.cycleExists) {
+            removeCycle(result.node, head);
+        }
+
+        return result.cycleExists;
+    }
+
+    /**
+     * @param loopNodeParam - reference to the node where Flyods cycle 
+     * finding algorithm ends, i.e. the fast and the slow iterators
+     * meet.
+     * @param head - reference to the head of the list
+     */
+    private static <T> void removeCycle(Node<T> loopNodeParam, Node<T> head) {
+        Node<T> it = head;
+
+        while (it != null) {
+            if (isNodeReachableFromLoopNode(it, loopNodeParam)) {
+                Node<T> loopStart = it;
+                findEndNodeAndBreakCycle(loopStart);
+                break;
+            }
+            it = it.next;
+        }
+    }
+
+    private static <T> boolean isNodeReachableFromLoopNode(Node<T> it, Node<T> loopNodeParam) {
+        Node<T> loopNode = loopNodeParam;
+
+        do {
+            if (it == loopNode) {
+                return true;
+            }
+            loopNode = loopNode.next;
+        } while (loopNode.next != loopNodeParam);
+
+        return false;
+    }
+
+    private static <T> void findEndNodeAndBreakCycle(Node<T> loopStartParam) {
+        Node<T> loopStart = loopStartParam;
+
+        while (loopStart.next != loopStartParam) {
+            loopStart = loopStart.next;
+        }
+
+        loopStart.next = null;
+    }
+}
--- a/algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleRemovalByCountingLoopNodes.java
+++ b/algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleRemovalByCountingLoopNodes.java
@ -0,0 +1,44 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleRemovalByCountingLoopNodes {
+
+    public static <T> boolean detectAndRemoveCycle(Node<T> head) {
+        CycleDetectionResult<T> result = CycleDetectionByFastAndSlowIterators.detectCycle(head);
+
+        if (result.cycleExists) {
+            removeCycle(result.node, head);
+        }
+
+        return result.cycleExists;
+    }
+
+    private static <T> void removeCycle(Node<T> loopNodeParam, Node<T> head) {
+        int cycleLength = calculateCycleLength(loopNodeParam);
+        Node<T> cycleLengthAdvancedIterator = head;
+        Node<T> it = head;
+
+        for (int i = 0; i < cycleLength; i++) {
+            cycleLengthAdvancedIterator = cycleLengthAdvancedIterator.next;
+        }
+
+        while (it.next != cycleLengthAdvancedIterator.next) {
+            it = it.next;
+            cycleLengthAdvancedIterator = cycleLengthAdvancedIterator.next;
+        }
+
+        cycleLengthAdvancedIterator.next = null;
+    }
+
+    private static <T> int calculateCycleLength(Node<T> loopNodeParam) {
+        Node<T> loopNode = loopNodeParam;
+        int length = 1;
+
+        while (loopNode.next != loopNodeParam) {
+            length++;
+            loopNode = loopNode.next;
+        }
+
+        return length;
+    }
+
+}
--- a/algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleRemovalWithoutCountingLoopNodes.java
+++ b/algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleRemovalWithoutCountingLoopNodes.java
@ -0,0 +1,27 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleRemovalWithoutCountingLoopNodes {
+
+    public static <T> boolean detectAndRemoveCycle(Node<T> head) {
+        CycleDetectionResult<T> result = CycleDetectionByFastAndSlowIterators.detectCycle(head);
+
+        if (result.cycleExists) {
+            removeCycle(result.node, head);
+        }
+
+        return result.cycleExists;
+    }
+
+    private static <T> void removeCycle(Node<T> meetingPointParam, Node<T> head) {
+        Node<T> loopNode = meetingPointParam;
+        Node<T> it = head;
+
+        while (loopNode.next != it.next) {
+            it = it.next;
+            loopNode = loopNode.next;
+        }
+
+        loopNode.next = null;
+    }
+
+}
--- a/algorithms/src/main/java/com/baeldung/algorithms/linkedlist/Node.java
+++ b/algorithms/src/main/java/com/baeldung/algorithms/linkedlist/Node.java
@ -0,0 +1,38 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class Node<T> {
+    T data;
+    Node<T> next;
+
+    public static <T> Node<T> createNewNode(T data, Node<T> next) {
+        Node<T> node = new Node<T>();
+        node.data = data;
+        node.next = next;
+        return node;
+    }
+
+    public static <T> void traverseList(Node<T> root) {
+        if (root == null) {
+            return;
+        }
+
+        Node<T> node = root;
+        while (node != null) {
+            System.out.println(node.data);
+            node = node.next;
+        }
+    }
+
+    public static <T> Node<T> getTail(Node<T> root) {
+        if (root == null) {
+            return null;
+        }
+
+        Node<T> node = root;
+        while (node.next != null) {
+            node = node.next;
+        }
+        return node;
+    }
+
+}
--- a/algorithms/src/main/java/com/baeldung/algorithms/string/search/StringSearchAlgorithms.java
+++ b/algorithms/src/main/java/com/baeldung/algorithms/string/search/StringSearchAlgorithms.java
@ -0,0 +1,194 @@
+package com.baeldung.algorithms.string.search;
+
+import java.math.BigInteger;
+import java.util.Random;
+
+public class StringSearchAlgorithms {
+    public static long getBiggerPrime(int m) {
+        BigInteger prime = BigInteger.probablePrime(getNumberOfBits(m) + 1, new Random());
+        return prime.longValue();
+    }
+
+    public static long getLowerPrime(long number) {
+        BigInteger prime = BigInteger.probablePrime(getNumberOfBits(number) - 1, new Random());
+        return prime.longValue();
+    }
+
+    private static int getNumberOfBits(final int number) {
+        return Integer.SIZE - Integer.numberOfLeadingZeros(number);
+    }
+
+    private static int getNumberOfBits(final long number) {
+        return Long.SIZE - Long.numberOfLeadingZeros(number);
+    }
+
+    public static int simpleTextSearch(char[] pattern, char[] text) {
+        int patternSize = pattern.length;
+        int textSize = text.length;
+
+        int i = 0;
+
+        while ((i + patternSize) <= textSize) {
+            int j = 0;
+            while (text[i + j] == pattern[j]) {
+                j += 1;
+                if (j >= patternSize)
+                    return i;
+            }
+            i += 1;
+        }
+
+        return -1;
+    }
+
+    public static int RabinKarpMethod(char[] pattern, char[] text) {
+        int patternSize = pattern.length; // m
+        int textSize = text.length; // n
+
+        long prime = getBiggerPrime(patternSize);
+
+        long r = 1;
+        for (int i = 0; i < patternSize - 1; i++) {
+            r *= 2;
+            r = r % prime;
+        }
+
+        long[] t = new long[textSize];
+        t[0] = 0;
+
+        long pfinger = 0;
+
+        for (int j = 0; j < patternSize; j++) {
+            t[0] = (2 * t[0] + text[j]) % prime;
+            pfinger = (2 * pfinger + pattern[j]) % prime;
+        }
+
+        int i = 0;
+        boolean passed = false;
+
+        int diff = textSize - patternSize;
+        for (i = 0; i <= diff; i++) {
+            if (t[i] == pfinger) {
+                passed = true;
+                for (int k = 0; k < patternSize; k++) {
+                    if (text[i + k] != pattern[k]) {
+                        passed = false;
+                        break;
+                    }
+                }
+
+                if (passed) {
+                    return i;
+                }
+            }
+
+            if (i < diff) {
+                long value = 2 * (t[i] - r * text[i]) + text[i + patternSize];
+                t[i + 1] = ((value % prime) + prime) % prime;
+            }
+        }
+        return -1;
+
+    }
+
+    public static int KnuthMorrisPrattSearch(char[] pattern, char[] text) {
+        int patternSize = pattern.length; // m
+        int textSize = text.length; // n
+
+        int i = 0, j = 0;
+
+        int[] shift = KnuthMorrisPrattShift(pattern);
+
+        while ((i + patternSize) <= textSize) {
+            while (text[i + j] == pattern[j]) {
+                j += 1;
+                if (j >= patternSize)
+                    return i;
+            }
+
+            if (j > 0) {
+                i += shift[j - 1];
+                j = Math.max(j - shift[j - 1], 0);
+            } else {
+                i++;
+                j = 0;
+            }
+        }
+        return -1;
+    }
+
+    public static int[] KnuthMorrisPrattShift(char[] pattern) {
+        int patternSize = pattern.length;
+
+        int[] shift = new int[patternSize];
+        shift[0] = 1;
+
+        int i = 1, j = 0;
+
+        while ((i + j) < patternSize) {
+            if (pattern[i + j] == pattern[j]) {
+                shift[i + j] = i;
+                j++;
+            } else {
+                if (j == 0)
+                    shift[i] = i + 1;
+
+                if (j > 0) {
+                    i = i + shift[j - 1];
+                    j = Math.max(j - shift[j - 1], 0);
+                } else {
+                    i = i + 1;
+                    j = 0;
+                }
+            }
+        }
+        return shift;
+    }
+
+    public static int BoyerMooreHorspoolSimpleSearch(char[] pattern, char[] text) {
+        int patternSize = pattern.length;
+        int textSize = text.length;
+
+        int i = 0, j = 0;
+
+        while ((i + patternSize) <= textSize) {
+            j = patternSize - 1;
+            while (text[i + j] == pattern[j]) {
+                j--;
+                if (j < 0)
+                    return i;
+            }
+            i++;
+        }
+        return -1;
+    }
+
+    public static int BoyerMooreHorspoolSearch(char[] pattern, char[] text) {
+
+        int shift[] = new int[256];
+
+        for (int k = 0; k < 256; k++) {
+            shift[k] = pattern.length;
+        }
+
+        for (int k = 0; k < pattern.length - 1; k++) {
+            shift[pattern[k]] = pattern.length - 1 - k;
+        }
+
+        int i = 0, j = 0;
+
+        while ((i + pattern.length) <= text.length) {
+            j = pattern.length - 1;
+
+            while (text[i + j] == pattern[j]) {
+                j -= 1;
+                if (j < 0)
+                    return i;
+            }
+
+            i = i + shift[text[i + pattern.length - 1]];
+
+        }
+        return -1;
+    }
+}
--- a/algorithms/src/test/java/algorithms/StringSearchAlgorithmsTest.java
+++ b/algorithms/src/test/java/algorithms/StringSearchAlgorithmsTest.java
@ -0,0 +1,25 @@
+package algorithms;
+
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.baeldung.algorithms.string.search.StringSearchAlgorithms;
+
+public class StringSearchAlgorithmsTest {
+	
+	
+	@Test
+	public void testStringSearchAlgorithms(){
+		String text = "This is some nice text.";
+		String pattern = "some";
+		
+		int realPosition = text.indexOf(pattern);
+        Assert.assertTrue(realPosition == StringSearchAlgorithms.simpleTextSearch(pattern.toCharArray(), text.toCharArray()));
+        Assert.assertTrue(realPosition == StringSearchAlgorithms.RabinKarpMethod(pattern.toCharArray(), text.toCharArray()));
+        Assert.assertTrue(realPosition == StringSearchAlgorithms.KnuthMorrisPrattSearch(pattern.toCharArray(), text.toCharArray()));
+        Assert.assertTrue(realPosition == StringSearchAlgorithms.BoyerMooreHorspoolSimpleSearch(pattern.toCharArray(), text.toCharArray()));
+        Assert.assertTrue(realPosition == StringSearchAlgorithms.BoyerMooreHorspoolSearch(pattern.toCharArray(), text.toCharArray()));
+	}
+
+}
--- a/algorithms/src/test/java/algorithms/binarysearch/BinarySearchTest.java
+++ b/algorithms/src/test/java/algorithms/binarysearch/BinarySearchTest.java
@ -0,0 +1,43 @@
+package algorithms.binarysearch;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Test;
+import com.baeldung.algorithms.binarysearch.BinarySearch;
+
+public class BinarySearchTest {
+
+    int[] sortedArray = { 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9 };
+    int key = 6;
+    int expectedIndexForSearchKey = 7;
+    int low = 0;
+    int high = sortedArray.length - 1;
+    List<Integer> sortedList = Arrays.asList(0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9);
+    
+    @Test
+    public void givenASortedArrayOfIntegers_whenBinarySearchRunIterativelyForANumber_thenGetIndexOfTheNumber() {
+        BinarySearch binSearch = new BinarySearch();
+        Assert.assertEquals(expectedIndexForSearchKey, binSearch.runBinarySearchIteratively(sortedArray, key, low, high));
+    }
+
+    @Test
+    public void givenASortedArrayOfIntegers_whenBinarySearchRunRecursivelyForANumber_thenGetIndexOfTheNumber() {
+        BinarySearch binSearch = new BinarySearch();
+        Assert.assertEquals(expectedIndexForSearchKey, binSearch.runBinarySearchRecursively(sortedArray, key, low, high));
+    }
+    
+    @Test
+    public void givenASortedArrayOfIntegers_whenBinarySearchRunUsingArraysClassStaticMethodForANumber_thenGetIndexOfTheNumber() {
+        BinarySearch binSearch = new BinarySearch();
+        Assert.assertEquals(expectedIndexForSearchKey, binSearch.runBinarySearchUsingJavaArrays(sortedArray, key));
+    }
+    
+    @Test
+    public void givenASortedListOfIntegers_whenBinarySearchRunUsingCollectionsClassStaticMethodForANumber_thenGetIndexOfTheNumber() {
+        BinarySearch binSearch = new BinarySearch();
+        Assert.assertEquals(expectedIndexForSearchKey, binSearch.runBinarySearchUsingJavaCollections(sortedList, key));
+    }
+    
+}
--- a/algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionBruteForceTest.java
+++ b/algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionBruteForceTest.java
@ -0,0 +1,23 @@
+package com.baeldung.algorithms.linkedlist;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(value = Parameterized.class)
+public class CycleDetectionBruteForceTest extends CycleDetectionTestBase {
+    boolean cycleExists;
+    Node<Integer> head;
+
+    public CycleDetectionBruteForceTest(Node<Integer> head, boolean cycleExists) {
+        super();
+        this.cycleExists = cycleExists;
+        this.head = head;
+    }
+
+    @Test
+    public void givenList_detectLoop() {
+        Assert.assertEquals(cycleExists, CycleDetectionBruteForce.detectCycle(head).cycleExists);
+    }
+}
--- a/algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionByFastAndSlowIteratorsTest.java
+++ b/algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionByFastAndSlowIteratorsTest.java
@ -0,0 +1,23 @@
+package com.baeldung.algorithms.linkedlist;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(value = Parameterized.class)
+public class CycleDetectionByFastAndSlowIteratorsTest extends CycleDetectionTestBase {
+    boolean cycleExists;
+    Node<Integer> head;
+
+    public CycleDetectionByFastAndSlowIteratorsTest(Node<Integer> head, boolean cycleExists) {
+        super();
+        this.cycleExists = cycleExists;
+        this.head = head;
+    }
+
+    @Test
+    public void givenList_detectLoop() {
+        Assert.assertEquals(cycleExists, CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
+    }
+}
--- a/algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionByHashingTest.java
+++ b/algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionByHashingTest.java
@ -0,0 +1,23 @@
+package com.baeldung.algorithms.linkedlist;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(value = Parameterized.class)
+public class CycleDetectionByHashingTest extends CycleDetectionTestBase {
+    boolean cycleExists;
+    Node<Integer> head;
+
+    public CycleDetectionByHashingTest(Node<Integer> head, boolean cycleExists) {
+        super();
+        this.cycleExists = cycleExists;
+        this.head = head;
+    }
+
+    @Test
+    public void givenList_detectLoop() {
+        Assert.assertEquals(cycleExists, CycleDetectionByHashing.detectCycle(head).cycleExists);
+    }
+}
--- a/algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionTestBase.java
+++ b/algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionTestBase.java
@ -0,0 +1,62 @@
+package com.baeldung.algorithms.linkedlist;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.junit.runners.Parameterized.Parameters;
+
+public class CycleDetectionTestBase {
+
+    @Parameters
+    public static Collection<Object[]> getLists() {
+        return Arrays.asList(new Object[][] { 
+            { createList(), false }, 
+            { createListWithLoop(), true },
+            { createListWithFullCycle(), true }, 
+            { createListWithSingleNodeInCycle(), true } 
+        });
+    }
+
+    public static Node<Integer> createList() {
+        Node<Integer> root = Node.createNewNode(10, null);
+
+        for (int i = 9; i >= 1; --i) {
+            Node<Integer> current = Node.createNewNode(i, root);
+            root = current;
+        }
+
+        return root;
+    }
+
+    public static Node<Integer> createListWithLoop() {
+        Node<Integer> node = createList();
+        createLoop(node);
+        return node;
+    }
+
+    public static Node<Integer> createListWithFullCycle() {
+        Node<Integer> head = createList();
+        Node<Integer> tail = Node.getTail(head);
+        tail.next = head;
+        return head;
+    }
+
+    public static Node<Integer> createListWithSingleNodeInCycle() {
+        Node<Integer> head = createList();
+        Node<Integer> tail = Node.getTail(head);
+        tail.next = tail;
+        return head;
+    }
+
+    public static void createLoop(Node<Integer> root) {
+        Node<Integer> tail = Node.getTail(root);
+
+        Node<Integer> middle = root;
+        for (int i = 1; i <= 4; i++) {
+            middle = middle.next;
+        }
+
+        tail.next = middle;
+    }
+
+}
--- a/algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleRemovalBruteForceTest.java
+++ b/algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleRemovalBruteForceTest.java
@ -0,0 +1,24 @@
+package com.baeldung.algorithms.linkedlist;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(value = Parameterized.class)
+public class CycleRemovalBruteForceTest extends CycleDetectionTestBase {
+    boolean cycleExists;
+    Node<Integer> head;
+
+    public CycleRemovalBruteForceTest(Node<Integer> head, boolean cycleExists) {
+        super();
+        this.cycleExists = cycleExists;
+        this.head = head;
+    }
+
+    @Test
+    public void givenList_ifLoopExists_thenDetectAndRemoveLoop() {
+        Assert.assertEquals(cycleExists, CycleRemovalBruteForce.detectAndRemoveCycle(head));
+        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
+    }
+}
--- a/algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleRemovalByCountingLoopNodesTest.java
+++ b/algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleRemovalByCountingLoopNodesTest.java
@ -0,0 +1,24 @@
+package com.baeldung.algorithms.linkedlist;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(value = Parameterized.class)
+public class CycleRemovalByCountingLoopNodesTest extends CycleDetectionTestBase {
+    boolean cycleExists;
+    Node<Integer> head;
+
+    public CycleRemovalByCountingLoopNodesTest(Node<Integer> head, boolean cycleExists) {
+        super();
+        this.cycleExists = cycleExists;
+        this.head = head;
+    }
+
+    @Test
+    public void givenList_ifLoopExists_thenDetectAndRemoveLoop() {
+        Assert.assertEquals(cycleExists, CycleRemovalByCountingLoopNodes.detectAndRemoveCycle(head));
+        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
+    }
+}
--- a/algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleRemovalWithoutCountingLoopNodesTest.java
+++ b/algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleRemovalWithoutCountingLoopNodesTest.java
@ -0,0 +1,24 @@
+package com.baeldung.algorithms.linkedlist;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(value = Parameterized.class)
+public class CycleRemovalWithoutCountingLoopNodesTest extends CycleDetectionTestBase {
+    boolean cycleExists;
+    Node<Integer> head;
+
+    public CycleRemovalWithoutCountingLoopNodesTest(Node<Integer> head, boolean cycleExists) {
+        super();
+        this.cycleExists = cycleExists;
+        this.head = head;
+    }
+
+    @Test
+    public void givenList_ifLoopExists_thenDetectAndRemoveLoop() {
+        Assert.assertEquals(cycleExists, CycleRemovalWithoutCountingLoopNodes.detectAndRemoveCycle(head));
+        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
+    }
+}
--- a/algorithms/src/test/java/com/baeldung/jgrapht/CompleteGraphTest.java
+++ b/algorithms/src/test/java/com/baeldung/jgrapht/CompleteGraphTest.java
@ -0,0 +1,38 @@
+package com.baeldung.jgrapht;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.List;
+
+import org.jgrapht.VertexFactory;
+import org.jgrapht.alg.HamiltonianCycle;
+import org.jgrapht.generate.CompleteGraphGenerator;
+import org.jgrapht.graph.DefaultEdge;
+import org.jgrapht.graph.SimpleWeightedGraph;
+import org.junit.Before;
+import org.junit.Test;
+
+public class CompleteGraphTest {
+
+    static SimpleWeightedGraph<String, DefaultEdge> completeGraph;
+    static int size = 10;
+
+    @Before
+    public void createCompleteGraph() {
+        completeGraph = new SimpleWeightedGraph<>(DefaultEdge.class);
+        CompleteGraphGenerator<String, DefaultEdge> completeGenerator = new CompleteGraphGenerator<String, DefaultEdge>(size);
+        VertexFactory<String> vFactory = new VertexFactory<String>() {
+            private int id = 0;
+            public String createVertex() {
+                return "v" + id++;
+            }
+        };
+        completeGenerator.generateGraph(completeGraph, vFactory, null);
+    }
+
+    @Test
+    public void givenCompleteGraph_whenGetHamiltonianCyclePath_thenGetVerticeListInSequence() {
+        List<String> verticeList = HamiltonianCycle.getApproximateOptimalForCompleteGraph(completeGraph);
+        assertEquals(verticeList.size(), completeGraph.vertexSet().size());
+    }
+}
--- a/algorithms/src/test/java/com/baeldung/jgrapht/DirectedGraphTests.java
+++ b/algorithms/src/test/java/com/baeldung/jgrapht/DirectedGraphTests.java
@ -0,0 +1,95 @@
+package com.baeldung.jgrapht;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.IntStream;
+
+import org.jgrapht.DirectedGraph;
+import org.jgrapht.GraphPath;
+import org.jgrapht.alg.CycleDetector;
+import org.jgrapht.alg.KosarajuStrongConnectivityInspector;
+import org.jgrapht.alg.interfaces.StrongConnectivityAlgorithm;
+import org.jgrapht.alg.shortestpath.AllDirectedPaths;
+import org.jgrapht.alg.shortestpath.BellmanFordShortestPath;
+import org.jgrapht.alg.shortestpath.DijkstraShortestPath;
+import org.jgrapht.graph.DefaultDirectedGraph;
+import org.jgrapht.graph.DefaultEdge;
+import org.jgrapht.graph.DirectedSubgraph;
+import org.jgrapht.traverse.BreadthFirstIterator;
+import org.jgrapht.traverse.DepthFirstIterator;
+import org.junit.Before;
+import org.junit.Test;
+
+public class DirectedGraphTests {
+    DirectedGraph<String, DefaultEdge> directedGraph;
+
+    @Before
+    public void createDirectedGraph() {
+        directedGraph = new DefaultDirectedGraph<String, DefaultEdge>(DefaultEdge.class);
+        IntStream.range(1, 10).forEach(i -> {
+            directedGraph.addVertex("v" + i);
+        });
+        directedGraph.addEdge("v1", "v2");
+        directedGraph.addEdge("v2", "v4");
+        directedGraph.addEdge("v4", "v3");
+        directedGraph.addEdge("v3", "v1");
+        directedGraph.addEdge("v5", "v4");
+        directedGraph.addEdge("v5", "v6");
+        directedGraph.addEdge("v6", "v7");
+        directedGraph.addEdge("v7", "v5");
+        directedGraph.addEdge("v8", "v5");
+        directedGraph.addEdge("v9", "v8");
+    }
+
+    @Test
+    public void givenDirectedGraph_whenGetStronglyConnectedSubgraphs_thenPathExistsBetweenStronglyconnectedVertices() {
+        StrongConnectivityAlgorithm<String, DefaultEdge> scAlg = new KosarajuStrongConnectivityInspector<>(directedGraph);
+        List<DirectedSubgraph<String, DefaultEdge>> stronglyConnectedSubgraphs = scAlg.stronglyConnectedSubgraphs();
+        List<String> stronglyConnectedVertices = new ArrayList<>(stronglyConnectedSubgraphs.get(3).vertexSet());
+
+        String randomVertex1 = stronglyConnectedVertices.get(0);
+        String randomVertex2 = stronglyConnectedVertices.get(3);
+        AllDirectedPaths<String, DefaultEdge> allDirectedPaths = new AllDirectedPaths<>(directedGraph);
+
+        List<GraphPath<String, DefaultEdge>> possiblePathList = allDirectedPaths.getAllPaths(randomVertex1, randomVertex2, false, stronglyConnectedVertices.size());
+        assertTrue(possiblePathList.size() > 0);
+    }
+
+    @Test
+    public void givenDirectedGraphWithCycle_whenCheckCycles_thenDetectCycles() {
+        CycleDetector<String, DefaultEdge> cycleDetector = new CycleDetector<String, DefaultEdge>(directedGraph);
+        assertTrue(cycleDetector.detectCycles());
+        Set<String> cycleVertices = cycleDetector.findCycles();
+        assertTrue(cycleVertices.size() > 0);
+    }
+
+    @Test
+    public void givenDirectedGraph_whenCreateInstanceDepthFirstIterator_thenGetIterator() {
+        DepthFirstIterator depthFirstIterator = new DepthFirstIterator<>(directedGraph);
+        assertNotNull(depthFirstIterator);
+    }
+
+    @Test
+    public void givenDirectedGraph_whenCreateInstanceBreadthFirstIterator_thenGetIterator() {
+        BreadthFirstIterator breadthFirstIterator = new BreadthFirstIterator<>(directedGraph);
+        assertNotNull(breadthFirstIterator);
+    }
+
+    @Test
+    public void givenDirectedGraph_whenGetDijkstraShortestPath_thenGetNotNullPath() {
+        DijkstraShortestPath dijkstraShortestPath = new DijkstraShortestPath(directedGraph);
+        List<String> shortestPath = dijkstraShortestPath.getPath("v1", "v4").getVertexList();
+        assertNotNull(shortestPath);
+    }
+
+    @Test
+    public void givenDirectedGraph_whenGetBellmanFordShortestPath_thenGetNotNullPath() {
+        BellmanFordShortestPath bellmanFordShortestPath = new BellmanFordShortestPath(directedGraph);
+        List<String> shortestPath = bellmanFordShortestPath.getPath("v1", "v4").getVertexList();
+        assertNotNull(shortestPath);
+    }
+}
--- a/algorithms/src/test/java/com/baeldung/jgrapht/EulerianCircuitTest.java
+++ b/algorithms/src/test/java/com/baeldung/jgrapht/EulerianCircuitTest.java
@ -0,0 +1,42 @@
+package com.baeldung.jgrapht;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.stream.IntStream;
+
+import org.jgrapht.GraphPath;
+import org.jgrapht.alg.cycle.HierholzerEulerianCycle;
+import org.jgrapht.graph.DefaultEdge;
+import org.jgrapht.graph.SimpleWeightedGraph;
+import org.junit.Before;
+import org.junit.Test;
+
+public class EulerianCircuitTest {
+    SimpleWeightedGraph<String, DefaultEdge> simpleGraph;
+
+    @Before
+    public void createGraphWithEulerianCircuit() {
+        simpleGraph = new SimpleWeightedGraph<>(DefaultEdge.class);
+        IntStream.range(1, 6).forEach(i -> {
+            simpleGraph.addVertex("v" + i);
+        });
+        IntStream.range(1, 6).forEach(i -> {
+            int endVertexNo = (i + 1) > 5 ? 1 : i + 1;
+            simpleGraph.addEdge("v" + i, "v" + endVertexNo);
+        });
+    }
+
+    @Test
+    public void givenGraph_whenCheckEluerianCycle_thenGetResult() {
+        HierholzerEulerianCycle eulerianCycle = new HierholzerEulerianCycle<>();
+        assertTrue(eulerianCycle.isEulerian(simpleGraph));
+    }
+
+    @Test
+    public void givenGraphWithEulerianCircuit_whenGetEulerianCycle_thenGetGraphPath() {
+        HierholzerEulerianCycle eulerianCycle = new HierholzerEulerianCycle<>();
+        GraphPath path = eulerianCycle.getEulerianCycle(simpleGraph);
+        assertTrue(path.getEdgeList().containsAll(simpleGraph.edgeSet()));
+    }
+}
--- a/animal-sniffer-mvn-plugin/pom.xml
+++ b/animal-sniffer-mvn-plugin/pom.xml
@ -0,0 +1,57 @@
+<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/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>com.baeldung</groupId>
+  <artifactId>animal-sniffer-mvn-plugin</artifactId>
+  <packaging>jar</packaging>
+  <version>1.0-SNAPSHOT</version>
+  <name>example-animal-sniffer-mvn-plugin</name>
+  <url>http://maven.apache.org</url>
+  
+  <properties>
+        <maven-compiler-plugin.version>3.6.0</maven-compiler-plugin.version>	
+    </properties>
+	
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>3.8.1</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+  <build>
+        <plugins>
+				 <plugin>
+				  <artifactId>maven-compiler-plugin</artifactId>
+				  <version>3.7.0</version>
+				  <configuration>
+					<source>1.6</source>
+					<target>1.6</target>
+				  </configuration>
+				</plugin>
+				<plugin>
+					<groupId>org.codehaus.mojo</groupId>
+					<artifactId>animal-sniffer-maven-plugin</artifactId>
+					<version>1.16</version>
+					<configuration>
+						<signature>
+							<groupId>org.codehaus.mojo.signature</groupId>
+							<artifactId>java16</artifactId>
+							<version>1.0</version>
+						</signature>
+					</configuration>
+					<executions>
+						<execution>
+							<id>animal-sniffer</id>
+							<phase>verify</phase>	
+							<goals>
+								<goal>check</goal>
+							</goals>
+						</execution>
+					</executions>
+				</plugin>
+        </plugins>
+
+    </build>
+</project>
--- a/animal-sniffer-mvn-plugin/src/main/java/com/baeldung/App.java
+++ b/animal-sniffer-mvn-plugin/src/main/java/com/baeldung/App.java
@ -0,0 +1,16 @@
+package com.baeldung;
+
+//import java.nio.charset.StandardCharsets;
+
+/**
+ * Hello world!
+ *
+ */
+public class App 
+{
+    public static void main( String[] args )
+    {
+        System.out.println( "Hello World!" );
+		//System.out.println(StandardCharsets.UTF_8.name());
+    }
+}
--- a/animal-sniffer-mvn-plugin/src/test/java/com/baeldung/AppTest.java
+++ b/animal-sniffer-mvn-plugin/src/test/java/com/baeldung/AppTest.java
@ -0,0 +1,40 @@
+package com.baeldung;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+/**
+ * Unit test for simple App.
+ */
+public class AppTest 
+    extends TestCase
+{
+    /**
+     * Create the test case
+     *
+     * @param testName name of the test case
+     */
+    public AppTest( String testName )
+    {
+        super( testName );
+    }
+
+    /**
+     * @return the suite of tests being tested
+     */
+    public static Test suite()
+    {
+        return new TestSuite( AppTest.class );
+    }
+
+    /**
+     * Rigourous Test :-)
+     */
+    public void testApp()
+    {
+		
+        assertTrue( true );
+		
+    }
+}
--- a/apache-cayenne/pom.xml
+++ b/apache-cayenne/pom.xml
@ -0,0 +1,59 @@
+<?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>apache-cayenne</artifactId>
+	<version>0.0.1-SNAPSHOT</version>
+	<packaging>jar</packaging>
+
+	<name>apache-cayenne</name>
+	<description>Introduction to Apache Cayenne</description>
+
+	<parent>
+		<groupId>com.baeldung</groupId>
+		<artifactId>parent-modules</artifactId>
+		<version>1.0.0-SNAPSHOT</version>
+	</parent>
+
+	<properties>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+		<java.version>1.8</java.version>
+		<mysql.connector.version>5.1.44</mysql.connector.version>
+		<cayenne.version>4.0.M5</cayenne.version>
+		<junit.version>4.12</junit.version>
+	</properties>
+
+	<dependencies>
+		<dependency>
+			<groupId>org.apache.cayenne</groupId>
+			<artifactId>cayenne-server</artifactId>
+			<version>${cayenne.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>mysql</groupId>
+			<artifactId>mysql-connector-java</artifactId>
+			<version>${mysql.connector.version}</version>
+			<scope>runtime</scope>
+		</dependency>
+
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+	<build>
+		<plugins>
+            <plugin>
+                <groupId>org.apache.cayenne.plugins</groupId>
+                <artifactId>cayenne-modeler-maven-plugin</artifactId>
+                <version>${cayenne.version}</version>
+            </plugin>
+		</plugins>
+	</build>
+
+</project>
--- a/apache-cayenne/src/main/java/com/baeldung/apachecayenne/persistent/Article.java
+++ b/apache-cayenne/src/main/java/com/baeldung/apachecayenne/persistent/Article.java
@ -0,0 +1,9 @@
+package com.baeldung.apachecayenne.persistent;
+
+import com.baeldung.apachecayenne.persistent.auto._Article;
+
+public class Article extends _Article {
+
+    private static final long serialVersionUID = 1L; 
+
+}
--- a/apache-cayenne/src/main/java/com/baeldung/apachecayenne/persistent/Author.java
+++ b/apache-cayenne/src/main/java/com/baeldung/apachecayenne/persistent/Author.java
@ -0,0 +1,9 @@
+package com.baeldung.apachecayenne.persistent;
+
+import com.baeldung.apachecayenne.persistent.auto._Author;
+
+public class Author extends _Author {
+
+    private static final long serialVersionUID = 1L; 
+
+}
--- a/apache-cayenne/src/main/java/com/baeldung/apachecayenne/persistent/auto/_Article.java
+++ b/apache-cayenne/src/main/java/com/baeldung/apachecayenne/persistent/auto/_Article.java
@ -0,0 +1,47 @@
+package com.baeldung.apachecayenne.persistent.auto;
+
+import org.apache.cayenne.CayenneDataObject;
+import org.apache.cayenne.exp.Property;
+
+import com.baeldung.apachecayenne.persistent.Author;
+
+/**
+ * Class _Article was generated by Cayenne.
+ * It is probably a good idea to avoid changing this class manually,
+ * since it may be overwritten next time code is regenerated.
+ * If you need to make any customizations, please use subclass.
+ */
+public abstract class _Article extends CayenneDataObject {
+
+    private static final long serialVersionUID = 1L; 
+
+    public static final String ID_PK_COLUMN = "id";
+
+    public static final Property<String> CONTENT = Property.create("content", String.class);
+    public static final Property<String> TITLE = Property.create("title", String.class);
+    public static final Property<Author> AUTHOR = Property.create("author", Author.class);
+
+    public void setContent(String content) {
+        writeProperty("content", content);
+    }
+    public String getContent() {
+        return (String)readProperty("content");
+    }
+
+    public void setTitle(String title) {
+        writeProperty("title", title);
+    }
+    public String getTitle() {
+        return (String)readProperty("title");
+    }
+
+    public void setAuthor(Author author) {
+        setToOneTarget("author", author, true);
+    }
+
+    public Author getAuthor() {
+        return (Author)readProperty("author");
+    }
+
+
+}
--- a/apache-cayenne/src/main/java/com/baeldung/apachecayenne/persistent/auto/_Author.java
+++ b/apache-cayenne/src/main/java/com/baeldung/apachecayenne/persistent/auto/_Author.java
@ -0,0 +1,44 @@
+package com.baeldung.apachecayenne.persistent.auto;
+
+import java.util.List;
+
+import org.apache.cayenne.CayenneDataObject;
+import org.apache.cayenne.exp.Property;
+
+import com.baeldung.apachecayenne.persistent.Article;
+
+/**
+ * Class _Author was generated by Cayenne.
+ * It is probably a good idea to avoid changing this class manually,
+ * since it may be overwritten next time code is regenerated.
+ * If you need to make any customizations, please use subclass.
+ */
+public abstract class _Author extends CayenneDataObject {
+
+    private static final long serialVersionUID = 1L; 
+
+    public static final String ID_PK_COLUMN = "id";
+
+    public static final Property<String> NAME = Property.create("name", String.class);
+    public static final Property<List<Article>> ARTICLES = Property.create("articles", List.class);
+
+    public void setName(String name) {
+        writeProperty("name", name);
+    }
+    public String getName() {
+        return (String)readProperty("name");
+    }
+
+    public void addToArticles(Article obj) {
+        addToManyTarget("articles", obj, true);
+    }
+    public void removeFromArticles(Article obj) {
+        removeToManyTarget("articles", obj, true);
+    }
+    @SuppressWarnings("unchecked")
+    public List<Article> getArticles() {
+        return (List<Article>)readProperty("articles");
+    }
+
+
+}
--- a/apache-cayenne/src/main/resources/cayenne-project.xml
+++ b/apache-cayenne/src/main/resources/cayenne-project.xml
@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<domain project-version="9">
+	<map name="datamap"/>
+
+	<node name="datanode"
+		 factory="org.apache.cayenne.configuration.server.XMLPoolingDataSourceFactory"
+		 schema-update-strategy="org.apache.cayenne.access.dbsync.CreateIfNoSchemaStrategy"
+		>
+		<map-ref name="datamap"/>
+		<data-source>
+			<driver value="com.mysql.jdbc.Driver"/>
+			<url value="jdbc:mysql://localhost:3306/intro_cayenne"/>
+			<connectionPool min="1" max="1"/>
+			<login userName="root" password="root"/>
+		</data-source>
+	</node>
+</domain>
--- a/apache-cayenne/src/main/resources/datamap.map.xml
+++ b/apache-cayenne/src/main/resources/datamap.map.xml
@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<data-map xmlns="http://cayenne.apache.org/schema/9/modelMap"
+	 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	 xsi:schemaLocation="http://cayenne.apache.org/schema/9/modelMap http://cayenne.apache.org/schema/9/modelMap.xsd"
+	 project-version="9">
+	<property name="defaultPackage" value="com.baeldung.apachecayenne.persistent"/>
+	<db-entity name="article" catalog="intro_cayenne">
+		<db-attribute name="author_id" type="INTEGER" isMandatory="true" length="10"/>
+		<db-attribute name="content" type="VARCHAR" isMandatory="true" length="254"/>
+		<db-attribute name="id" type="INTEGER" isPrimaryKey="true" isGenerated="true" isMandatory="true" length="10"/>
+		<db-attribute name="title" type="VARCHAR" isMandatory="true" length="254"/>
+	</db-entity>
+	<db-entity name="author" catalog="intro_cayenne">
+		<db-attribute name="id" type="INTEGER" isPrimaryKey="true" isGenerated="true" isMandatory="true" length="10"/>
+		<db-attribute name="name" type="VARCHAR" isMandatory="true" length="254"/>
+	</db-entity>
+	<obj-entity name="Article" className="com.baeldung.apachecayenne.persistent.Article" dbEntityName="article">
+		<obj-attribute name="content" type="java.lang.String" db-attribute-path="content"/>
+		<obj-attribute name="title" type="java.lang.String" db-attribute-path="title"/>
+	</obj-entity>
+	<obj-entity name="Author" className="com.baeldung.apachecayenne.persistent.Author" dbEntityName="author">
+		<obj-attribute name="name" type="java.lang.String" db-attribute-path="name"/>
+	</obj-entity>
+	<db-relationship name="author" source="article" target="author" toMany="false">
+		<db-attribute-pair source="author_id" target="id"/>
+	</db-relationship>
+	<db-relationship name="articles" source="author" target="article" toMany="true">
+		<db-attribute-pair source="id" target="author_id"/>
+	</db-relationship>
+	<obj-relationship name="author" source="Article" target="Author" deleteRule="Nullify" db-relationship-path="author"/>
+	<obj-relationship name="articles" source="Author" target="Article" deleteRule="Deny" db-relationship-path="articles"/>
+</data-map>
--- a/apache-cayenne/src/test/java/com/baeldung/apachecayenne/CayenneOperationTests.java
+++ b/apache-cayenne/src/test/java/com/baeldung/apachecayenne/CayenneOperationTests.java
@ -0,0 +1,131 @@
+package com.baeldung.apachecayenne;
+
+import com.baeldung.apachecayenne.persistent.Article;
+import com.baeldung.apachecayenne.persistent.Author;
+import org.apache.cayenne.ObjectContext;
+import org.apache.cayenne.configuration.server.ServerRuntime;
+import org.apache.cayenne.query.ObjectSelect;
+import org.apache.cayenne.query.SQLTemplate;
+import org.junit.After;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.List;
+
+import static junit.framework.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+
+public class CayenneOperationTests {
+    private static ObjectContext context = null;
+
+    @BeforeClass
+    public static void setupTheCayenneContext() {
+        ServerRuntime cayenneRuntime = ServerRuntime.builder()
+                .addConfig("cayenne-project.xml")
+                .build();
+        context = cayenneRuntime.newContext();
+    }
+
+    @After
+    public void deleteAllRecords() {
+        SQLTemplate deleteArticles = new SQLTemplate(Article.class, "delete from article");
+        SQLTemplate deleteAuthors = new SQLTemplate(Author.class, "delete from author");
+
+        context.performGenericQuery(deleteArticles);
+        context.performGenericQuery(deleteAuthors);
+    }
+
+    @Test
+    public void givenAuthor_whenInsert_thenWeGetOneRecordInTheDatabase() {
+        Author author = context.newObject(Author.class);
+        author.setName("Paul");
+
+        context.commitChanges();
+
+        long records = ObjectSelect.dataRowQuery(Author.class).selectCount(context);
+        assertEquals(1, records);
+    }
+
+    @Test
+    public void givenAuthor_whenInsert_andQueryByFirstName_thenWeGetTheAuthor() {
+        Author author = context.newObject(Author.class);
+        author.setName("Paul");
+
+        context.commitChanges();
+
+        Author expectedAuthor = ObjectSelect.query(Author.class)
+                .where(Author.NAME.eq("Paul"))
+                .selectOne(context);
+
+        assertEquals("Paul", expectedAuthor.getName());
+    }
+
+    @Test
+    public void givenTwoAuthor_whenInsert_andQueryAll_thenWeGetTwoAuthors() {
+        Author firstAuthor = context.newObject(Author.class);
+        firstAuthor.setName("Paul");
+
+        Author secondAuthor = context.newObject(Author.class);
+        secondAuthor.setName("Ludovic");
+
+        context.commitChanges();
+
+        List<Author> authors = ObjectSelect.query(Author.class).select(context);
+        assertEquals(2, authors.size());
+    }
+
+    @Test
+    public void givenAuthor_whenUpdating_thenWeGetAnUpatedeAuthor() {
+        Author author = context.newObject(Author.class);
+        author.setName("Paul");
+        context.commitChanges();
+
+        Author expectedAuthor = ObjectSelect.query(Author.class)
+                .where(Author.NAME.eq("Paul"))
+                .selectOne(context);
+        expectedAuthor.setName("Garcia");
+        context.commitChanges();
+
+        assertEquals(author.getName(), expectedAuthor.getName());
+    }
+
+    @Test
+    public void givenAuthor_whenDeleting_thenWeLostHisDetails() {
+        Author author = context.newObject(Author.class);
+        author.setName("Paul");
+        context.commitChanges();
+
+        Author savedAuthor = ObjectSelect.query(Author.class)
+                .where(Author.NAME.eq("Paul")).selectOne(context);
+        if(savedAuthor != null) {
+            context.deleteObjects(author);
+            context.commitChanges();
+        }
+
+        Author expectedAuthor = ObjectSelect.query(Author.class)
+                .where(Author.NAME.eq("Paul")).selectOne(context);
+        assertNull(expectedAuthor);
+    }
+
+    @Test
+    public void givenAuthor_whenAttachingToArticle_thenTheRelationIsMade() {
+        Author author = context.newObject(Author.class);
+        author.setName("Paul");
+
+        Article article = context.newObject(Article.class);
+        article.setTitle("My post title");
+        article.setContent("The content");
+        article.setAuthor(author);
+
+        context.commitChanges();
+
+        Author expectedAuthor = ObjectSelect.query(Author.class)
+                .where(Author.NAME.eq("Paul"))
+                .selectOne(context);
+
+        Article expectedArticle = (expectedAuthor.getArticles()).get(0);
+        assertEquals(article.getTitle(), expectedArticle.getTitle());
+    }
+
+}
--- a/apache-shiro/.gitignore
+++ b/apache-shiro/.gitignore
@ -0,0 +1,4 @@
+
+/.idea/
+/target/
+/apache-shiro.iml
--- a/apache-shiro/README.md
+++ b/apache-shiro/README.md
@ -0,0 +1,2 @@
+### Relevant articles
+- [Introduction to Apache Shiro](http://www.baeldung.com/apache-shiro)
--- a/apache-shiro/pom.xml
+++ b/apache-shiro/pom.xml
@ -0,0 +1,78 @@
+<?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>
+
+    <groupId>com.baeldung</groupId>
+    <artifactId>apache-shiro</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>1.5.2.RELEASE</version>
+    </parent>
+
+    <properties>
+        <apache-shiro-core-version>1.4.0</apache-shiro-core-version>
+        <log4j-version>1.2.17</log4j-version>
+        <slf4j-version>1.7.25</slf4j-version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-freemarker</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.shiro</groupId>
+            <artifactId>shiro-spring-boot-web-starter</artifactId>
+            <version>${apache-shiro-core-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.shiro</groupId>
+            <artifactId>shiro-core</artifactId>
+            <version>${apache-shiro-core-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>jcl-over-slf4j</artifactId>
+            <version>${slf4j-version}</version>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-log4j12</artifactId>
+            <version>${slf4j-version}</version>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>log4j</groupId>
+            <artifactId>log4j</artifactId>
+            <version>${log4j-version}</version>
+            <scope>runtime</scope>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.6.2</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    
+</project>
--- a/apache-shiro/src/main/java/com/baeldung/Main.java
+++ b/apache-shiro/src/main/java/com/baeldung/Main.java
@ -0,0 +1,85 @@
+package com.baeldung;
+
+import org.apache.shiro.SecurityUtils;
+import org.apache.shiro.authc.*;
+import org.apache.shiro.mgt.DefaultSecurityManager;
+import org.apache.shiro.mgt.SecurityManager;
+import org.apache.shiro.realm.Realm;
+import org.apache.shiro.realm.text.IniRealm;
+import org.apache.shiro.session.Session;
+import org.apache.shiro.subject.Subject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Main {
+
+    private static final transient Logger log = LoggerFactory.getLogger(Main.class);
+
+    public static void main(String[] args) {
+
+        Realm realm = new MyCustomRealm();
+        SecurityManager securityManager = new DefaultSecurityManager(realm);
+
+        SecurityUtils.setSecurityManager(securityManager);
+        Subject currentUser = SecurityUtils.getSubject();
+
+        if (!currentUser.isAuthenticated()) {
+          UsernamePasswordToken token 
+            = new UsernamePasswordToken("user", "password");
+          token.setRememberMe(true);
+          try {
+              currentUser.login(token);
+          } catch (UnknownAccountException uae) {
+              log.error("Username Not Found!", uae);
+          } catch (IncorrectCredentialsException ice) {
+              log.error("Invalid Credentials!", ice);
+          } catch (LockedAccountException lae) {
+              log.error("Your Account is Locked!", lae);
+          } catch (AuthenticationException ae) {
+              log.error("Unexpected Error!", ae);
+          }
+        }
+
+        log.info("User [" + currentUser.getPrincipal() + "] logged in successfully.");
+
+        if (currentUser.hasRole("admin")) {
+            log.info("Welcome Admin");
+        } else if(currentUser.hasRole("editor")) {
+            log.info("Welcome, Editor!");
+        } else if(currentUser.hasRole("author")) {
+            log.info("Welcome, Author");
+        } else {
+            log.info("Welcome, Guest");
+        }
+
+        if(currentUser.isPermitted("articles:compose")) {
+            log.info("You can compose an article");
+        } else {
+            log.info("You are not permitted to compose an article!");
+        }
+
+        if(currentUser.isPermitted("articles:save")) {
+            log.info("You can save articles");
+        } else {
+            log.info("You can not save articles");
+        }
+
+        if(currentUser.isPermitted("articles:publish")) {
+            log.info("You can publish articles");
+        } else {
+            log.info("You can not publish articles");
+        }
+
+        Session session = currentUser.getSession();
+        session.setAttribute("key", "value");
+        String value = (String) session.getAttribute("key");
+        if (value.equals("value")) {
+            log.info("Retrieved the correct value! [" + value + "]");
+        }
+
+        currentUser.logout();
+
+        System.exit(0);
+    }
+
+}
--- a/apache-shiro/src/main/java/com/baeldung/MyCustomRealm.java
+++ b/apache-shiro/src/main/java/com/baeldung/MyCustomRealm.java
@ -0,0 +1,102 @@
+package com.baeldung;
+
+import org.apache.shiro.authc.*;
+import org.apache.shiro.authz.AuthorizationInfo;
+import org.apache.shiro.authz.SimpleAuthorizationInfo;
+import org.apache.shiro.realm.jdbc.JdbcRealm;
+import org.apache.shiro.subject.PrincipalCollection;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.*;
+
+public class MyCustomRealm extends JdbcRealm {
+
+    private Map<String, String> credentials = new HashMap<>();
+    private Map<String, Set<String>> roles = new HashMap<>();
+    private Map<String, Set<String>> perm = new HashMap<>();
+
+    {
+      credentials.put("user", "password");
+      credentials.put("user2", "password2");
+      credentials.put("user3", "password3");
+
+      roles.put("user", new HashSet<>(Arrays.asList("admin")));
+      roles.put("user2", new HashSet<>(Arrays.asList("editor")));
+      roles.put("user3", new HashSet<>(Arrays.asList("author")));
+
+      perm.put("admin", new HashSet<>(Arrays.asList("*")));
+      perm.put("editor", new HashSet<>(Arrays.asList("articles:*")));
+      perm.put("author",
+        new HashSet<>(Arrays.asList("articles:compose",
+          "articles:save")));
+
+    }
+
+    @Override
+    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token)
+      throws AuthenticationException {
+
+        UsernamePasswordToken uToken = (UsernamePasswordToken) token;
+
+        if(uToken.getUsername() == null
+          || uToken.getUsername().isEmpty()
+          || !credentials.containsKey(uToken.getUsername())
+          ) {
+            throw new UnknownAccountException("username not found!");
+        }
+
+
+        return new SimpleAuthenticationInfo(
+          uToken.getUsername(), credentials.get(uToken.getUsername()),
+          getName());
+    }
+
+    @Override
+    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
+        Set<String> roleNames = new HashSet<>();
+        Set<String> permissions = new HashSet<>();
+
+        principals.forEach(p -> {
+            try {
+                Set<String> roles = getRoleNamesForUser(null, (String) p);
+                roleNames.addAll(roles);
+                permissions.addAll(getPermissions(null, null,roles));
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        });
+
+        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo(roleNames);
+        info.setStringPermissions(permissions);
+        return info;
+    }
+
+    @Override
+    protected Set<String> getRoleNamesForUser(Connection conn, String username) throws SQLException {
+        if(!roles.containsKey(username)) {
+            throw new SQLException("username not found!");
+        }
+
+       return roles.get(username);
+    }
+
+    @Override
+    protected Set<String> getPermissions(Connection conn, String username, Collection<String> roleNames) throws SQLException {
+        for (String role : roleNames) {
+            if (!perm.containsKey(role)) {
+                throw new SQLException("role not found!");
+            }
+        }
+
+        Set<String> finalSet = new HashSet<>();
+        for (String role : roleNames) {
+            finalSet.addAll(perm.get(role));
+        }
+
+        return finalSet;
+    }
+
+}
--- a/apache-shiro/src/main/java/com/baeldung/ShiroSpringApplication.java
+++ b/apache-shiro/src/main/java/com/baeldung/ShiroSpringApplication.java
@ -0,0 +1,45 @@
+package com.baeldung;
+
+import org.apache.shiro.realm.Realm;
+import org.apache.shiro.spring.web.config.DefaultShiroFilterChainDefinition;
+import org.apache.shiro.spring.web.config.ShiroFilterChainDefinition;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+
+/**
+ * Created by smatt on 21/08/2017.
+ */
+@SpringBootApplication
+public class ShiroSpringApplication {
+
+    private static final transient Logger log = LoggerFactory.getLogger(ShiroSpringApplication.class);
+
+    public static void main(String... args) {
+        SpringApplication.run(ShiroSpringApplication.class, args);
+    }
+
+
+    @Bean
+    public Realm realm() {
+        return new MyCustomRealm();
+    }
+
+
+    @Bean
+    public ShiroFilterChainDefinition shiroFilterChainDefinition() {
+        DefaultShiroFilterChainDefinition filter
+          = new DefaultShiroFilterChainDefinition();
+
+        filter.addPathDefinition("/secure", "authc");
+        filter.addPathDefinition("/**", "anon");
+
+        return filter;
+    }
+
+
+
+
+}
--- a/apache-shiro/src/main/java/com/baeldung/controllers/ShiroSpringController.java
+++ b/apache-shiro/src/main/java/com/baeldung/controllers/ShiroSpringController.java
@ -0,0 +1,105 @@
+package com.baeldung.controllers;
+
+import com.baeldung.models.UserCredentials;
+import org.apache.shiro.SecurityUtils;
+import org.apache.shiro.authc.AuthenticationException;
+import org.apache.shiro.authc.UsernamePasswordToken;
+import org.apache.shiro.subject.Subject;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.ModelMap;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.servlet.mvc.support.RedirectAttributes;
+
+import javax.servlet.http.HttpServletRequest;
+
+@Controller
+public class ShiroSpringController {
+
+
+
+    @GetMapping("/")
+    public String index() {
+       return "index";
+    }
+
+
+    @RequestMapping( value = "/login", method = {RequestMethod.GET, RequestMethod.POST})
+    public String login(HttpServletRequest req, UserCredentials cred, RedirectAttributes attr) {
+
+      if(req.getMethod().equals(RequestMethod.GET.toString())) {
+        return "login";
+      }
+      else {
+
+        Subject subject = SecurityUtils.getSubject();
+
+        if(!subject.isAuthenticated()) {
+          UsernamePasswordToken token = new UsernamePasswordToken(
+            cred.getUsername(), cred.getPassword(), cred.isRememberMe());
+          try {
+            subject.login(token);
+          } catch (AuthenticationException ae) {
+              ae.printStackTrace();
+              attr.addFlashAttribute("error", "Invalid Credentials");
+              return "redirect:/login";
+          }
+        }
+
+        return "redirect:/secure";
+      }
+    }
+
+
+    @GetMapping("/secure")
+    public String secure(ModelMap modelMap) {
+
+        Subject currentUser = SecurityUtils.getSubject();
+        String role = "", permission = "";
+
+        if(currentUser.hasRole("admin")) {
+            role = role  + "You are an Admin";
+        }
+        else if(currentUser.hasRole("editor")) {
+            role = role + "You are an Editor";
+        }
+        else if(currentUser.hasRole("author")) {
+            role = role + "You are an Author";
+        }
+
+        if(currentUser.isPermitted("articles:compose")) {
+            permission = permission + "You can compose an article, ";
+        } else {
+            permission = permission + "You are not permitted to compose an article!, ";
+        }
+
+        if(currentUser.isPermitted("articles:save")) {
+            permission = permission + "You can save articles, ";
+        } else {
+            permission = permission + "\nYou can not save articles, ";
+        }
+
+        if(currentUser.isPermitted("articles:publish")) {
+            permission = permission  + "\nYou can publish articles";
+        } else {
+            permission = permission + "\nYou can not publish articles";
+        }
+
+        modelMap.addAttribute("username", currentUser.getPrincipal());
+        modelMap.addAttribute("permission", permission);
+        modelMap.addAttribute("role", role);
+
+        return "secure";
+    }
+
+
+    @PostMapping("/logout")
+    public String logout() {
+       Subject subject = SecurityUtils.getSubject();
+       subject.logout();
+       return "redirect:/";
+    }
+
+}
--- a/apache-shiro/src/main/java/com/baeldung/models/UserCredentials.java
+++ b/apache-shiro/src/main/java/com/baeldung/models/UserCredentials.java
@ -0,0 +1,40 @@
+package com.baeldung.models;
+
+public class UserCredentials {
+
+    private String username;
+    private String password;
+    private boolean rememberMe = false;
+
+    public UserCredentials() {}
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public boolean isRememberMe() {
+        return rememberMe;
+    }
+
+    public void setRememberMe(boolean rememberMe) {
+        this.rememberMe = rememberMe;
+    }
+
+    @Override
+    public String toString() {
+        return "username = " + getUsername()
+                + "\nrememberMe = " + isRememberMe();
+    }
+}
--- a/apache-shiro/src/main/resources/application.properties
+++ b/apache-shiro/src/main/resources/application.properties
@ -0,0 +1,11 @@
+server.port=9000
+server.servlet-path=/
+server.context-path=/
+
+#shiro-spring-boot-config
+shiro.loginUrl = /login
+shiro.successUrl = /secure
+shiro.unauthorizedUrl = /login
+
+#freemarker
+spring.freemarker.suffix=.ftl
--- a/apache-shiro/src/main/resources/log4j.properties
+++ b/apache-shiro/src/main/resources/log4j.properties
@ -0,0 +1,12 @@
+log4j.rootLogger=INFO, stdout
+
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m %n
+
+log4j.logger.org.apache=WARN
+
+log4j.logger.org.apache.shiro=INFO
+
+log4j.logger.org.apache.shiro.util.ThreadContext=WARN
+log4j.logger.org.apache.shiro.cache.ehcache.EhCache=WARN
--- a/apache-shiro/src/main/resources/shiro.ini
+++ b/apache-shiro/src/main/resources/shiro.ini
@ -0,0 +1,9 @@
+[users]
+user = password,admin
+user2 = password2,editor
+user3 = password3,author
+
+[roles]
+admin = *
+editor = articles:*
+author = articles:compose,articles:save
--- a/apache-shiro/src/main/resources/templates/index.ftl
+++ b/apache-shiro/src/main/resources/templates/index.ftl
@ -0,0 +1,10 @@
+<html>
+<head>
+    <title>Index</title>
+</head>
+<body>
+    <h1>Welcome Guest!</h1>
+    <br>
+    <a href="/login">Login</a>
+</body>
+</html>
--- a/apache-shiro/src/main/resources/templates/login.ftl
+++ b/apache-shiro/src/main/resources/templates/login.ftl
@ -0,0 +1,27 @@
+<html>
+<head>
+    <title>Login</title>
+</head>
+<body style="margin-left: 30px;">
+<h3>Login</h3>
+<br>
+<form action="/login" method="post">
+    <#if (error?length > 0)??>
+        <p style="color:darkred;">${error}</p>
+    <#else>
+    </#if>
+
+    <label for="username">Username</label>
+    <br>
+    <input type="text" name="username">
+    <br><br>
+    <label for="password">Password</label>
+    <br>
+    <input type="password" name="password">
+    <br><br>
+    <input type="checkbox" name="rememberMe"> Remember Me
+    <br><br>
+    <input type="submit" value="Submit">
+</form>
+</body>
+</html>
--- a/apache-shiro/src/main/resources/templates/secure.ftl
+++ b/apache-shiro/src/main/resources/templates/secure.ftl
@ -0,0 +1,15 @@
+<html>
+<head>
+    <title>Secure</title>
+</head>
+<body style="margin-left: 30px;">
+<h1>Welcome ${username}!</h1>
+<p><strong>Role</strong>: ${role}</p>
+<p><strong>Permissions</strong></p>
+<p>${permission}</p>
+<br>
+<form role="form" action="/logout" method="POST">
+   <input type="Submit" value="Logout" />
+</form>
+</body>
+</html>
--- a/apache-velocity/src/main/webapp/WEB-INF/velocity.properties
+++ b/apache-velocity/src/main/webapp/WEB-INF/velocity.properties
@ -1,4 +1,4 @@
 resource.loader=webapp
 webapp.resource.loader.class=org.apache.velocity.tools.view.WebappResourceLoader
-webapp.resource.loader.path = .
+webapp.resource.loader.path = 
 webapp.resource.loader.cache = true
--- a/asciidoctor/README.md
+++ b/asciidoctor/README.md
@ -1,3 +1,4 @@
 ### Relevant articles

 - [Introduction to Asciidoctor](http://www.baeldung.com/introduction-to-asciidoctor)
+- [Generating a Book with Asciidoctor](http://www.baeldung.com/asciidoctor-book)
--- a/atomix/.gitignore
+++ b/atomix/.gitignore
@ -0,0 +1 @@
+/target
--- a/core-java/hashcode/pom.xml
+++ b/core-java/hashcode/pom.xml
@ -1,16 +1,39 @@
-<?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 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.hashcode</groupId>
-    <artifactId>hashcode</artifactId>
-    <version>1.0</version>
+    <groupId>com.atomix.io</groupId>
+    <artifactId>atomix</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>io.atomix</groupId>
+            <artifactId>atomix-all</artifactId>
+            <version>1.0.0-rc9</version>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.9</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>log4j</groupId>
+            <artifactId>log4j</artifactId>
+            <version>1.2.17</version>
+        </dependency>
+    </dependencies>
    <build>
        <plugins>
            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.7.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
@ -18,22 +41,6 @@
            </plugin>
        </plugins>
    </build>
-    <dependencies>
-        <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <version>4.12</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.slf4j</groupId>
-            <artifactId>slf4j-api</artifactId>
-            <version>1.7.25</version>
-        </dependency>
-        <dependency>
-            <groupId>org.slf4j</groupId>
-            <artifactId>slf4j-simple</artifactId>
-            <version>1.7.25</version>
-        </dependency>
-    </dependencies>
+
+
 </project>
--- a/atomix/src/main/java/com/atomix/example/BootstrapingCluster.java
+++ b/atomix/src/main/java/com/atomix/example/BootstrapingCluster.java
@ -0,0 +1,27 @@
+package com.atomix.example;
+
+import io.atomix.AtomixReplica;
+import io.atomix.catalyst.transport.Address;
+import io.atomix.catalyst.transport.netty.NettyTransport;
+import io.atomix.copycat.server.storage.Storage;
+import io.atomix.copycat.server.storage.StorageLevel;
+
+import java.io.File;
+import java.util.concurrent.CompletableFuture;
+
+public class BootstrapingCluster {
+
+    public static void main(String[] args) {
+        Storage storage = Storage.builder()
+          .withDirectory(new File("log"))
+          .withStorageLevel(StorageLevel.DISK)
+          .build();
+        AtomixReplica replica = AtomixReplica.builder(new Address("localhost", 8700))
+          .withStorage(storage)
+          .withTransport(new NettyTransport())
+          .build();
+
+        CompletableFuture<AtomixReplica> completableFuture = replica.bootstrap();
+        completableFuture.join();
+    }
+}
--- a/atomix/src/main/java/com/atomix/example/OtherNodes.java
+++ b/atomix/src/main/java/com/atomix/example/OtherNodes.java
@ -0,0 +1,71 @@
+package com.atomix.example;
+
+import io.atomix.AtomixReplica;
+import io.atomix.catalyst.transport.Address;
+import io.atomix.catalyst.transport.netty.NettyTransport;
+import io.atomix.concurrent.DistributedLock;
+import io.atomix.copycat.server.storage.Storage;
+import io.atomix.copycat.server.storage.StorageLevel;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.List;
+
+public class OtherNodes {
+
+    public static void main(String[] args) throws InterruptedException {
+        List<Address> cluster = Arrays
+          .asList(
+            new Address("localhost", 8700),
+            new Address("localhost", 8701),
+            new Address("localhost", 8702));
+
+        Storage storage = Storage.builder()
+          .withDirectory(new File("log"))
+          .withStorageLevel(StorageLevel.DISK)
+          .build();
+
+        AtomixReplica replica2 = AtomixReplica.builder(new Address("localhost", 8701))
+          .withStorage(storage)
+          .withTransport(new NettyTransport())
+          .build();
+
+        WorkerThread WT1 = new WorkerThread(replica2, cluster);
+        WT1.run();
+
+        AtomixReplica replica3 = AtomixReplica.builder(new Address("localhost", 8702))
+          .withStorage(storage)
+          .withTransport(new NettyTransport())
+          .build();
+
+        WorkerThread WT2 = new WorkerThread(replica3, cluster);
+        WT2.run();
+
+        Thread.sleep(6000);
+
+        DistributedLock lock = replica2.getLock("my-lock")
+          .join();
+        lock.lock()
+          .thenRun(() -> System.out.println("Acquired a lock"));
+
+        replica2.getMap("map")
+          .thenCompose(m -> m.put("bar", "Hello world!"))
+          .thenRun(() -> System.out.println("Value is set in Distributed Map"))
+          .join();
+    }
+
+    private static class WorkerThread extends Thread {
+        private AtomixReplica replica;
+        private List<Address> cluster;
+
+        WorkerThread(AtomixReplica replica, List<Address> cluster) {
+            this.replica = replica;
+            this.cluster = cluster;
+        }
+
+        public void run() {
+            replica.join(cluster)
+              .join();
+        }
+    }
+}
--- a/atomix/src/test/java/com/atomix/exampletest/AtomixClientLiveTest.java
+++ b/atomix/src/test/java/com/atomix/exampletest/AtomixClientLiveTest.java
@ -0,0 +1,35 @@
+package com.atomix.exampletest;
+
+import io.atomix.AtomixClient;
+import io.atomix.catalyst.transport.Address;
+import io.atomix.catalyst.transport.netty.NettyTransport;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+
+import static org.junit.Assert.assertEquals;
+
+public class AtomixClientLiveTest {
+
+    private final AtomixClient client = AtomixClient.builder()
+      .withTransport(new NettyTransport())
+      .build();
+
+    @Test
+    public void whenBootstrap_thenShouldGet() throws InterruptedException, ExecutionException {
+        List<Address> cluster = Arrays.asList(
+          new Address("localhost", 8700),
+          new Address("localhsot", 8701));
+
+        String value = client.connect(cluster)
+          .thenRun(() -> System.out.println("Client Connected"))
+          .thenCompose(c -> client.getMap("map"))
+          .thenCompose(m -> m.get("bar"))
+          .thenApply(a -> (String) a)
+          .get();
+
+        assertEquals("Hello world!", value);
+    }
+}
--- a/bootique/README.md
+++ b/bootique/README.md
@ -0,0 +1,2 @@
+### Relevant Articles:
+- [Introduction to Bootique](http://www.baeldung.com/bootique)
--- a/bootique/config.yml
+++ b/bootique/config.yml
@ -0,0 +1,11 @@
+log:
+  level: warn
+  appenders:
+    - type: file
+      logFormat: '%c{20}: %m%n'
+      file: /home/logger.log
+
+jetty:
+  context: /hello
+  connector:
+    port: 10001
--- a/bootique/dependency-reduced-pom.xml
+++ b/bootique/dependency-reduced-pom.xml
@ -0,0 +1,50 @@
+<?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/maven-v4_0_0.xsd">
+  <parent>
+    <artifactId>bootique-parent</artifactId>
+    <groupId>io.bootique.parent</groupId>
+    <version>0.12</version>
+  </parent>
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>com.baeldung.bootique</groupId>
+  <artifactId>bootique</artifactId>
+  <name>bootique</name>
+  <version>1.0-SNAPSHOT</version>
+  <url>http://maven.apache.org</url>
+  <build>
+    <plugins>
+      <plugin>
+        <artifactId>maven-shade-plugin</artifactId>
+      </plugin>
+    </plugins>
+  </build>
+  <dependencies>
+    <dependency>
+      <groupId>io.bootique</groupId>
+      <artifactId>bootique-test</artifactId>
+      <version>0.23</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>3.8.1</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+  <dependencyManagement>
+    <dependencies>
+      <dependency>
+        <groupId>io.bootique.bom</groupId>
+        <artifactId>bootique-bom</artifactId>
+        <version>0.23</version>
+        <type>pom</type>
+        <scope>import</scope>
+      </dependency>
+    </dependencies>
+  </dependencyManagement>
+  <properties>
+    <main.class>com.baeldung.bootique.App</main.class>
+  </properties>
+</project>
+
--- a/bootique/pom.xml
+++ b/bootique/pom.xml
@ -0,0 +1,66 @@
+<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/maven-v4_0_0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<groupId>com.baeldung.bootique</groupId>
+	<artifactId>bootique</artifactId>
+	<packaging>jar</packaging>
+	<version>1.0-SNAPSHOT</version>
+	<name>bootique</name>
+	<url>http://maven.apache.org</url>
+
+	<properties>
+		<main.class>com.baeldung.bootique.App</main.class>
+	</properties>
+
+	<parent>
+		<groupId>io.bootique.parent</groupId>
+		<artifactId>bootique-parent</artifactId>
+		<version>0.12</version>
+	</parent>
+
+	<dependencyManagement>
+		<dependencies>
+			<dependency>
+				<groupId>io.bootique.bom</groupId>
+				<artifactId>bootique-bom</artifactId>
+				<version>0.23</version>
+				<type>pom</type>
+				<scope>import</scope>
+			</dependency>
+		</dependencies>
+	</dependencyManagement>
+
+	<dependencies>
+		<dependency>
+			<groupId>io.bootique.jersey</groupId>
+			<artifactId>bootique-jersey</artifactId>
+			<scope>compile</scope>
+		</dependency>
+		<dependency>
+			<groupId>io.bootique.logback</groupId>
+			<artifactId>bootique-logback</artifactId>
+			<scope>compile</scope>
+		</dependency>
+		<dependency>
+			<groupId>io.bootique</groupId>
+			<artifactId>bootique-test</artifactId>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>4.12</version>
+			<scope>test</scope>
+		</dependency>
+	</dependencies>
+
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-shade-plugin</artifactId>
+			</plugin>
+		</plugins>
+	</build>
+
+</project>
--- a/bootique/src/main/java/com/baeldung/bootique/App.java
+++ b/bootique/src/main/java/com/baeldung/bootique/App.java
@ -0,0 +1,41 @@
+package com.baeldung.bootique;
+
+import com.baeldung.bootique.module.ModuleBinder;
+import com.baeldung.bootique.router.IndexController;
+import com.baeldung.bootique.router.SaveController;
+import com.google.inject.Module;
+import io.bootique.Bootique;
+import io.bootique.jersey.JerseyModule;
+import io.bootique.log.BootLogger;
+
+import java.util.function.Supplier;
+
+public class App {
+
+    public static void main(String[] args) {
+        Module module = binder -> JerseyModule.extend(binder).addResource(IndexController.class)
+          .addResource(SaveController.class);
+        Bootique.app(args).module(module).module(ModuleBinder.class).bootLogger(new BootLogger() {
+            @Override
+            public void trace(Supplier<String> arg0) {
+                // ...
+            }
+
+            @Override
+            public void stdout(String arg0) {
+                // ...
+            }
+
+            @Override
+            public void stderr(String arg0, Throwable arg1) {
+                // ...
+            }
+
+            @Override
+            public void stderr(String arg0) {
+                // ...
+            }
+        }).autoLoadModules().exec();
+    }
+
+}
--- a/bootique/src/main/java/com/baeldung/bootique/module/ModuleBinder.java
+++ b/bootique/src/main/java/com/baeldung/bootique/module/ModuleBinder.java
@ -0,0 +1,15 @@
+package com.baeldung.bootique.module;
+
+import com.baeldung.bootique.service.HelloService;
+import com.baeldung.bootique.service.impl.HelloServiceImpl;
+import com.google.inject.Binder;
+import com.google.inject.Module;
+
+public class ModuleBinder implements Module {
+
+    @Override
+    public void configure(Binder binder) {
+        binder.bind(HelloService.class).to(HelloServiceImpl.class);
+    }
+
+}
--- a/bootique/src/main/java/com/baeldung/bootique/module/ModuleProvider.java
+++ b/bootique/src/main/java/com/baeldung/bootique/module/ModuleProvider.java
@ -0,0 +1,13 @@
+package com.baeldung.bootique.module;
+
+import com.google.inject.Module;
+import io.bootique.BQModuleProvider;
+
+public class ModuleProvider implements BQModuleProvider {
+
+    @Override
+    public Module module() {
+        return new ModuleBinder();
+    }
+
+}
--- a/bootique/src/main/java/com/baeldung/bootique/router/IndexController.java
+++ b/bootique/src/main/java/com/baeldung/bootique/router/IndexController.java
@ -0,0 +1,14 @@
+package com.baeldung.bootique.router;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+
+@Path("/")
+public class IndexController {
+
+    @GET
+    public String index() {
+        return "Hello, baeldung!";
+    }
+
+}
--- a/bootique/src/main/java/com/baeldung/bootique/router/SaveController.java
+++ b/bootique/src/main/java/com/baeldung/bootique/router/SaveController.java
@ -0,0 +1,20 @@
+package com.baeldung.bootique.router;
+
+import com.baeldung.bootique.service.HelloService;
+import com.google.inject.Inject;
+
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+
+@Path("/save")
+public class SaveController {
+
+    @Inject
+    HelloService helloService;
+
+    @POST
+    public String save() {
+        return "Data Saved!";
+    }
+
+}
--- a/bootique/src/main/java/com/baeldung/bootique/service/HelloService.java
+++ b/bootique/src/main/java/com/baeldung/bootique/service/HelloService.java
@ -0,0 +1,7 @@
+package com.baeldung.bootique.service;
+
+public interface HelloService {
+
+	boolean save();
+
+}
--- a/bootique/src/main/java/com/baeldung/bootique/service/impl/HelloServiceImpl.java
+++ b/bootique/src/main/java/com/baeldung/bootique/service/impl/HelloServiceImpl.java
@ -0,0 +1,12 @@
+package com.baeldung.bootique.service.impl;
+
+import com.baeldung.bootique.service.HelloService;
+
+public class HelloServiceImpl implements HelloService {
+
+	@Override
+	public boolean save() {
+		return true;
+	}
+
+}
--- a/bootique/src/main/resources/META-INF/services/io.bootique.BQModuleProvider
+++ b/bootique/src/main/resources/META-INF/services/io.bootique.BQModuleProvider
@ -0,0 +1 @@
+com.baeldung.bootique.module.ModuleProvider
--- a/bootique/src/test/java/com/baeldung/bootique/AppTest.java
+++ b/bootique/src/test/java/com/baeldung/bootique/AppTest.java
@ -0,0 +1,27 @@
+package com.baeldung.bootique;
+
+import com.baeldung.bootique.service.HelloService;
+import io.bootique.BQRuntime;
+import io.bootique.test.junit.BQDaemonTestFactory;
+import io.bootique.test.junit.BQTestFactory;
+import org.junit.Rule;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class AppTest {
+
+    @Rule
+    public BQTestFactory bqTestFactory = new BQTestFactory();
+
+    @Rule
+    public BQDaemonTestFactory bqDaemonTestFactory = new BQDaemonTestFactory();
+
+    @Test
+    public void givenService_expectBoolen() {
+        BQRuntime runtime = bqTestFactory.app("--server").autoLoadModules().createRuntime();
+        HelloService service = runtime.getInstance(HelloService.class);
+        assertEquals(true, service.save());
+    }
+
+}
--- a/core-java-8/.gitignore
+++ b/core-java-8/.gitignore
@ -0,0 +1,26 @@
+*.class
+
+0.*
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+.resourceCache
+
+# Packaged files #
+*.jar
+*.war
+*.ear
+
+# Files generated by integration tests
+*.txt
+backup-pom.xml
+/bin/
+/temp
+
+#IntelliJ specific
+.idea/
+*.iml
--- a/core-java-8/README.md
+++ b/core-java-8/README.md
@ -0,0 +1,32 @@
+=========
+
+## Core Java 8 Cookbooks and Examples
+
+### Relevant Articles: 
+- [Java 8 Collectors](http://www.baeldung.com/java-8-collectors)
+- [Guide to Java 8’s Functional Interfaces](http://www.baeldung.com/java-8-functional-interfaces)
+- [Java 8 – Powerful Comparison with Lambdas](http://www.baeldung.com/java-8-sort-lambda)
+- [Java 8 New Features](http://www.baeldung.com/java-8-new-features)
+- [Lambda Expressions and Functional Interfaces: Tips and Best Practices](http://www.baeldung.com/java-8-lambda-expressions-tips)
+- [The Double Colon Operator in Java 8](http://www.baeldung.com/java-8-double-colon-operator)
+- [Java 8 Streams Advanced](http://www.baeldung.com/java-8-streams)
+- [Introduction to Java 8 Streams](http://www.baeldung.com/java-8-streams-introduction)
+- [Guide to Java 8 groupingBy Collector](http://www.baeldung.com/java-groupingby-collector)
+- [Strategy Design Pattern in Java 8](http://www.baeldung.com/java-strategy-pattern)
+- [Java 8 and Infinite Streams](http://www.baeldung.com/java-inifinite-streams)
+- [String Operations with Java Streams](http://www.baeldung.com/java-stream-operations-on-strings)
+- [Exceptions in Java 8 Lambda Expressions](http://www.baeldung.com/java-lambda-exceptions)
+- [Java 8 Stream findFirst() vs. findAny()](http://www.baeldung.com/java-stream-findfirst-vs-findany)
+- [Guide to Java 8 Comparator.comparing()](http://www.baeldung.com/java-8-comparator-comparing)
+- [How to Get the Last Element of a Stream in Java?](http://www.baeldung.com/java-stream-last-element)
+- [Introduction to the Java 8 Date/Time API](http://www.baeldung.com/java-8-date-time-intro)
+- [Migrating to the New Java 8 Date Time API](http://www.baeldung.com/migrating-to-java-8-date-time-api)
+- [Guide To Java 8 Optional](http://www.baeldung.com/java-optional)
+- [Guide to the Java 8 forEach](http://www.baeldung.com/foreach-java)
+- [Get the Current Date, Time and Timestamp in Java 8](http://www.baeldung.com/current-date-time-and-timestamp-in-java-8)
+- [TemporalAdjuster in Java](http://www.baeldung.com/java-temporal-adjuster)
+- [Finding Max/Min of a List or Collection](http://www.baeldung.com/java-collection-min-max)
+- [Java Base64 Encoding and Decoding](http://www.baeldung.com/java-base64-encode-and-decode)
+- [The Difference Between map() and flatMap()](http://www.baeldung.com/java-difference-map-and-flatmap)
+
+- [Merging Streams in Java](http://www.baeldung.com/java-merge-streams)
--- a/core-java-8/pom.xml
+++ b/core-java-8/pom.xml
@ -0,0 +1,258 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.baeldung</groupId>
+    <artifactId>core-java-8</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+
+    <name>core-java-8</name>
+
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+
+        <!-- utils -->
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>${guava.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-collections4</artifactId>
+            <version>${commons-collections4.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>${commons-io.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-math3</artifactId>
+            <version>${commons-math3.version}</version>
+        </dependency>
+
+       <dependency>
+            <groupId>log4j</groupId>
+            <artifactId>log4j</artifactId>
+            <version>1.2.17</version>
+        </dependency>
+        
+        <dependency>
+            <groupId>commons-codec</groupId>
+            <artifactId>commons-codec</artifactId>
+            <version>${commons-codec.version}</version>
+        </dependency>        
+
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        
+        <!-- test scoped -->
+
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>com.jayway.awaitility</groupId>
+            <artifactId>awaitility</artifactId>
+            <version>${avaitility.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <finalName>core-java-8</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-dependency-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <id>copy-dependencies</id>
+                        <phase>prepare-package</phase>
+                        <goals>
+                            <goal>copy-dependencies</goal>
+                        </goals>
+                        <configuration>
+                            <outputDirectory>${project.build.directory}/libs</outputDirectory>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <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>
+                <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>
+                <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>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>repackage</goal>
+                        </goals>
+                        <configuration>
+                            <classifier>spring-boot</classifier>
+                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+
+    </build>
+
+    <profiles>
+        <profile>
+            <id>integration</id>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-surefire-plugin</artifactId>
+                        <executions>
+                            <execution>
+                                <phase>integration-test</phase>
+                                <goals>
+                                    <goal>test</goal>
+                                </goals>
+                                <configuration>
+                                    <excludes>
+                                        <exclude>**/*ManualTest.java</exclude>
+                                    </excludes>
+                                    <includes>
+                                        <include>**/*IntegrationTest.java</include>
+                                    </includes>
+                                </configuration>
+                            </execution>
+                        </executions>
+                        <configuration>
+                            <systemPropertyVariables>
+                                <test.mime>json</test.mime>
+                            </systemPropertyVariables>
+                        </configuration>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+    </profiles>
+    
+    <properties>
+
+        <!-- util -->
+        <guava.version>21.0</guava.version>
+        <commons-lang3.version>3.5</commons-lang3.version>
+        <commons-math3.version>3.6.1</commons-math3.version>
+        <commons-io.version>2.5</commons-io.version>
+        <commons-collections4.version>4.1</commons-collections4.version>
+        <collections-generic.version>4.01</collections-generic.version>
+        <commons-codec.version>1.10</commons-codec.version>
+        <lombok.version>1.16.12</lombok.version>
+
+        <!-- testing -->
+        <assertj.version>3.6.1</assertj.version>
+        <avaitility.version>1.7.0</avaitility.version>
+
+    </properties>
+</project>
--- a/core-java-8/src/main/java/com/baeldung/Adder.java
+++ b/core-java-8/src/main/java/com/baeldung/Adder.java
--- a/core-java-8/src/main/java/com/baeldung/AdderImpl.java
+++ b/core-java-8/src/main/java/com/baeldung/AdderImpl.java
@ -1,5 +1,6 @@
 package com.baeldung;

+
 import java.util.function.Consumer;
 import java.util.function.Function;

--- a/core-java-8/src/main/java/com/baeldung/Bar.java
+++ b/core-java-8/src/main/java/com/baeldung/Bar.java
@ -1,5 +1,6 @@
 package com.baeldung;

+
@FunctionalInterface
 public interface Bar {

--- a/core-java-8/src/main/java/com/baeldung/Baz.java
+++ b/core-java-8/src/main/java/com/baeldung/Baz.java
@ -1,5 +1,6 @@
 package com.baeldung;

+
@FunctionalInterface
 public interface Baz {

--- a/core-java-8/src/main/java/com/baeldung/Foo.java
+++ b/core-java-8/src/main/java/com/baeldung/Foo.java
@ -1,5 +1,6 @@
 package com.baeldung;

+
@FunctionalInterface
 public interface Foo {

--- a/core-java-8/src/main/java/com/baeldung/FooExtended.java
+++ b/core-java-8/src/main/java/com/baeldung/FooExtended.java
@ -1,5 +1,6 @@
 package com.baeldung;

+
@FunctionalInterface
 public interface FooExtended extends Baz, Bar {

--- a/core-java-8/src/main/java/com/baeldung/UseFoo.java
+++ b/core-java-8/src/main/java/com/baeldung/UseFoo.java
@ -1,5 +1,6 @@
 package com.baeldung;

+
 import java.util.function.Function;

 public class UseFoo {
--- a/core-java-8/src/main/java/com/baeldung/datetime/README.md
+++ b/core-java-8/src/main/java/com/baeldung/datetime/README.md
--- a/core-java-8/src/main/java/com/baeldung/datetime/UseDuration.java
+++ b/core-java-8/src/main/java/com/baeldung/datetime/UseDuration.java
--- a/core-java-8/src/main/java/com/baeldung/datetime/UseLocalDate.java
+++ b/core-java-8/src/main/java/com/baeldung/datetime/UseLocalDate.java
--- a/core-java-8/src/main/java/com/baeldung/datetime/UseLocalDateTime.java
+++ b/core-java-8/src/main/java/com/baeldung/datetime/UseLocalDateTime.java
@ -0,0 +1,11 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDateTime;
+
+public class UseLocalDateTime {
+
+    public LocalDateTime getLocalDateTimeUsingParseMethod(String representation) {
+        return LocalDateTime.parse(representation);
+    }
+
+}
--- a/core-java-8/src/main/java/com/baeldung/datetime/UseLocalTime.java
+++ b/core-java-8/src/main/java/com/baeldung/datetime/UseLocalTime.java
--- a/core-java-8/src/main/java/com/baeldung/datetime/UsePeriod.java
+++ b/core-java-8/src/main/java/com/baeldung/datetime/UsePeriod.java
--- a/core-java-8/src/main/java/com/baeldung/datetime/UseToInstant.java
+++ b/core-java-8/src/main/java/com/baeldung/datetime/UseToInstant.java
--- a/core-java-8/src/main/java/com/baeldung/datetime/UseZonedDateTime.java
+++ b/core-java-8/src/main/java/com/baeldung/datetime/UseZonedDateTime.java
--- a/core-java-8/src/main/java/com/baeldung/doublecolon/Computer.java
+++ b/core-java-8/src/main/java/com/baeldung/doublecolon/Computer.java
--- a/core-java-8/src/main/java/com/baeldung/doublecolon/ComputerUtils.java
+++ b/core-java-8/src/main/java/com/baeldung/doublecolon/ComputerUtils.java
--- a/core-java-8/src/main/java/com/baeldung/doublecolon/MacbookPro.java
+++ b/core-java-8/src/main/java/com/baeldung/doublecolon/MacbookPro.java
--- a/core-java-8/src/main/java/com/baeldung/doublecolon/function/ComputerPredicate.java
+++ b/core-java-8/src/main/java/com/baeldung/doublecolon/function/ComputerPredicate.java
--- a/core-java-8/src/main/java/com/baeldung/doublecolon/function/TriFunction.java
+++ b/core-java-8/src/main/java/com/baeldung/doublecolon/function/TriFunction.java
--- a/core-java-8/src/main/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappers.java
+++ b/core-java-8/src/main/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappers.java
--- a/core-java-8/src/main/java/com/baeldung/java8/lambda/exceptions/ThrowingConsumer.java
+++ b/core-java-8/src/main/java/com/baeldung/java8/lambda/exceptions/ThrowingConsumer.java
--- a/core-java-8/src/main/java/com/baeldung/java_8_features/Address.java
+++ b/core-java-8/src/main/java/com/baeldung/java_8_features/Address.java
--- a/core-java-8/src/main/java/com/baeldung/java_8_features/CustomException.java
+++ b/core-java-8/src/main/java/com/baeldung/java_8_features/CustomException.java
--- a/core-java-8/src/main/java/com/baeldung/java_8_features/Detail.java
+++ b/core-java-8/src/main/java/com/baeldung/java_8_features/Detail.java
--- a/core-java-8/src/main/java/com/baeldung/java_8_features/OptionalAddress.java
+++ b/core-java-8/src/main/java/com/baeldung/java_8_features/OptionalAddress.java
--- a/Show More
+++ b/Show More