Merge branch 'master' into BAEL-2804

Conflicts:
	persistence-modules/java-jpa-2/README.md
	persistence-modules/java-jpa-2/pom.xml
	persistence-modules/java-jpa/pom.xml
	persistence-modules/pom.xml

.gitignore

@@ -1,4 +1,5 @@
 */bin/*
+bin/
 
 *.class
 
@@ -21,6 +22,9 @@
 *.iws
 out/
 
+# VSCode
+.vscode/
+
 # Mac
 .DS_Store
 
@@ -77,4 +81,5 @@ apache-avro/src/main/java/com/baeldung/avro/model/
 jta/transaction-logs/
 software-security/sql-injection-samples/derby.log
 spring-soap/src/main/java/com/baeldung/springsoap/gen/
-/report-*.json
+/report-*.json
+transaction.log

README.md

@@ -1,12 +1,16 @@
 
-The "REST with Spring" Classes
+The Courses
 ==============================
 
-Here's the Master Class of REST With Spring (along with the newly announced Boot 2 material): <br/>
-**[>> THE REST WITH SPRING - MASTER CLASS](http://www.baeldung.com/rest-with-spring-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=rws#master-class)**
 
-And here's the Master Class of Learn Spring Security: <br/>
-**[>> LEARN SPRING SECURITY - MASTER CLASS](http://www.baeldung.com/learn-spring-security-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=lss#master-class)**
+Here's the new "Learn Spring" course: <br/>
+**[>> LEARN SPRING - THE MASTER CLASS](https://www.baeldung.com/learn-spring-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=ls#master-class)**
+
+Here's the Master Class of "REST With Spring" (along with the new announced Boot 2 material): <br/>
+**[>> THE REST WITH SPRING - MASTER CLASS](https://www.baeldung.com/rest-with-spring-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=rws#master-class)**
+
+And here's the Master Class of "Learn Spring Security": <br/>
+**[>> LEARN SPRING SECURITY - MASTER CLASS](https://www.baeldung.com/learn-spring-security-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=lss#master-class)**
 
 
 
@@ -15,7 +19,7 @@ Java and Spring Tutorials
 
 This project is **a collection of small and focused tutorials** - each covering a single and well defined area of development in the Java ecosystem. 
 A strong focus of these is, of course, the Spring Framework - Spring, Spring Boot and Spring Security. 
-In additional to Spring, the following technologies are in focus: `core Java`, `Jackson`, `HttpClient`, `Guava`. 
+In additional to Spring, the modules here are covering a number of aspects in Java. 
 
 
 Building the project
@@ -32,8 +36,15 @@ Running a Spring Boot module
 ====================
 To run a Spring Boot module run the command: `mvn spring-boot:run` in the module directory
 
-#Running Tests
 
+Working with the IDE
+====================
+This repo contains a large number of modules. 
+When you're working with an individual module, there's no need to import all of them (or build all of them) - you can simply import that particular module in either Eclipse or IntelliJ. 
+
+
+Running Tests
+=============
 The command `mvn clean install` will run the unit tests in a module.
 To run the integration tests, use the command `mvn clean install -Pintegration-lite-first`
 

algorithms-miscellaneous-1/pom.xml

@@ -42,7 +42,7 @@
         <dependency>
             <groupId>com.github.dpaukov</groupId>
             <artifactId>combinatoricslib3</artifactId>
-            <version>3.3.0</version>
+            <version>${combinatoricslib3.version}</version>
          </dependency>
     </dependencies>
 
@@ -83,6 +83,7 @@
         <org.assertj.core.version>3.9.0</org.assertj.core.version>
         <commons-codec.version>1.11</commons-codec.version>
         <guava.version>27.0.1-jre</guava.version>
+        <combinatoricslib3.version>3.3.0</combinatoricslib3.version>
     </properties>
 
 </project>

algorithms-miscellaneous-3/README.md

@@ -1,6 +1,9 @@
-## Relevant articles:
+## Relevant Articles:
 
 - [Java Two Pointer Technique](https://www.baeldung.com/java-two-pointer-technique)
 - [Implementing Simple State Machines with Java Enums](https://www.baeldung.com/java-enum-simple-state-machine)
 - [Converting Between Roman and Arabic Numerals in Java](http://www.baeldung.com/java-convert-roman-arabic)
 - [Practical Java Examples of the Big O Notation](http://www.baeldung.com/java-algorithm-complexity)
+- [Checking If a List Is Sorted in Java](https://www.baeldung.com/java-check-if-list-sorted)
+- [Checking if a Java Graph has a Cycle](https://www.baeldung.com/java-graph-has-a-cycle)
+- [A Guide to the Folding Technique in Java](https://www.baeldung.com/folding-hashing-technique)

algorithms-miscellaneous-3/pom.xml

@@ -18,6 +18,18 @@
             <version>${org.assertj.core.version}</version>
             <scope>test</scope>
         </dependency>
+        
+        <dependency>
+        	<groupId>org.apache.commons</groupId>
+        	<artifactId>commons-collections4</artifactId>
+        	<version>${commons-collections4.version}</version>
+        </dependency>
+        
+        <dependency>
+        	<groupId>com.google.guava</groupId>
+        	<artifactId>guava</artifactId>
+        	<version>${guava.version}</version>
+        </dependency>
     </dependencies>
 
     <build>
@@ -34,6 +46,7 @@
 
     <properties>
         <org.assertj.core.version>3.9.0</org.assertj.core.version>
+        <commons-collections4.version>4.3</commons-collections4.version>
+        <guava.version>28.0-jre</guava.version>
     </properties>
-
 </project>

algorithms-miscellaneous-3/src/main/java/com/baeldung/algorithms/checksortedlist/Employee.java

@@ -0,0 +1,34 @@
+package com.baeldung.algorithms.checksortedlist;
+
+public class Employee {
+
+    long id;
+
+    String name;
+
+    public Employee() {
+    }
+
+    public Employee(long id, String name) {
+        super();
+        this.id = id;
+        this.name = name;
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+}

algorithms-miscellaneous-3/src/main/java/com/baeldung/algorithms/checksortedlist/SortedListChecker.java

@@ -0,0 +1,87 @@
+package com.baeldung.algorithms.checksortedlist;
+
+import static org.apache.commons.collections4.CollectionUtils.isEmpty;
+
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+
+import com.google.common.collect.Comparators;
+import com.google.common.collect.Ordering;;
+
+public class SortedListChecker {
+
+    private SortedListChecker() {
+        throw new AssertionError();
+    }
+
+    public static boolean checkIfSortedUsingIterativeApproach(List<String> listOfStrings) {
+        if (isEmpty(listOfStrings) || listOfStrings.size() == 1) {
+            return true;
+        }
+
+        Iterator<String> iter = listOfStrings.iterator();
+        String current, previous = iter.next();
+        while (iter.hasNext()) {
+            current = iter.next();
+            if (previous.compareTo(current) > 0) {
+                return false;
+            }
+            previous = current;
+        }
+        return true;
+    }
+
+    public static boolean checkIfSortedUsingIterativeApproach(List<Employee> employees, Comparator<Employee> employeeComparator) {
+        if (isEmpty(employees) || employees.size() == 1) {
+            return true;
+        }
+
+        Iterator<Employee> iter = employees.iterator();
+        Employee current, previous = iter.next();
+        while (iter.hasNext()) {
+            current = iter.next();
+            if (employeeComparator.compare(previous, current) > 0) {
+                return false;
+            }
+            previous = current;
+        }
+        return true;
+    }
+
+    public static boolean checkIfSortedUsingRecursion(List<String> listOfStrings) {
+        return isSortedRecursive(listOfStrings, listOfStrings.size());
+    }
+
+    public static boolean isSortedRecursive(List<String> listOfStrings, int index) {
+        if (index < 2) {
+            return true;
+        } else if (listOfStrings.get(index - 2)
+            .compareTo(listOfStrings.get(index - 1)) > 0) {
+            return false;
+        } else {
+            return isSortedRecursive(listOfStrings, index - 1);
+        }
+    }
+
+    public static boolean checkIfSortedUsingOrderingClass(List<String> listOfStrings) {
+        return Ordering.<String> natural()
+            .isOrdered(listOfStrings);
+    }
+
+    public static boolean checkIfSortedUsingOrderingClass(List<Employee> employees, Comparator<Employee> employeeComparator) {
+        return Ordering.from(employeeComparator)
+            .isOrdered(employees);
+    }
+
+    public static boolean checkIfSortedUsingOrderingClassHandlingNull(List<String> listOfStrings) {
+        return Ordering.<String> natural()
+            .nullsLast()
+            .isOrdered(listOfStrings);
+    }
+
+    public static boolean checkIfSortedUsingComparators(List<String> listOfStrings) {
+        return Comparators.isInOrder(listOfStrings, Comparator.<String> naturalOrder());
+    }
+
+}

algorithms-miscellaneous-3/src/main/java/com/baeldung/algorithms/stringsortingbynumber/NaturalOrderComparators.java

@@ -0,0 +1,30 @@
+package com.baeldung.algorithms.stringsortingbynumber;
+
+import java.util.Comparator;
+
+public final class NaturalOrderComparators {
+
+    private static final String DIGIT_AND_DECIMAL_REGEX = "[^\\d.]";
+
+    private NaturalOrderComparators() {
+        throw new AssertionError("Let's keep this static");
+    }
+
+    public static Comparator<String> createNaturalOrderRegexComparator() {
+        return Comparator.comparingDouble(NaturalOrderComparators::parseStringToNumber);
+    }
+
+    private static double parseStringToNumber(String input){
+
+        final String digitsOnly = input.replaceAll(DIGIT_AND_DECIMAL_REGEX, "");
+
+        if("".equals(digitsOnly)) return 0;
+
+        try{
+            return Double.parseDouble(digitsOnly);
+        }catch (NumberFormatException nfe){
+            return 0;
+        }
+    }
+
+}

algorithms-miscellaneous-3/src/main/java/com/baeldung/folding/FoldingHash.java

@@ -0,0 +1,78 @@
+package com.baeldung.folding;
+
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+/**
+ * Calculate a hash value for the strings using the folding technique.
+ * 
+ * The implementation serves only to the illustration purposes and is far
+ * from being the most efficient. 
+ * 
+ * @author A.Shcherbakov
+ *
+ */
+public class FoldingHash {
+
+    /**
+     * Calculate the hash value of a given string.
+     * 
+     * @param str Assume it is not null
+     * @param groupSize the group size in the folding technique
+     * @param maxValue defines a max value that the hash may acquire (exclusive)     
+     * @return integer value from 0 (inclusive) to maxValue (exclusive)
+     */
+    public int hash(String str, int groupSize, int maxValue) {
+        final int[] codes = this.toAsciiCodes(str);
+        return IntStream.range(0, str.length())
+            .filter(i -> i % groupSize == 0)
+            .mapToObj(i -> extract(codes, i, groupSize))
+            .map(block -> concatenate(block))
+            .reduce(0, (a, b) -> (a + b) % maxValue);
+    }
+
+    /**
+     * Returns a new array of given length whose elements are take from 
+     * the original one starting from the offset.
+     *  
+     * If the original array has not enough elements, the returning array will contain 
+     * element from the offset till the end of the original array.
+     *  
+     * @param numbers original array. Assume it is not null.
+     * @param offset index of the element to start from. Assume it is less than the size of the array 
+     * @param length max size of the resulting array
+     * @return
+     */
+    public int[] extract(int[] numbers, int offset, int length) {
+        final int defect = numbers.length - (offset + length);
+        final int s = defect < 0 ? length + defect : length;
+        int[] result = new int[s];
+        for (int index = 0; index < s; index++) {
+            result[index] = numbers[index + offset];
+        }
+        return result;
+    }
+
+    /**
+     * Concatenate the numbers into a single number as if they were strings.
+     * Assume that the procedure does not suffer from the overflow.
+     * @param numbers integers to concatenate
+     * @return
+     */
+    public int concatenate(int[] numbers) {
+        final String merged = IntStream.of(numbers)
+            .mapToObj(number -> "" + number)
+            .collect(Collectors.joining());
+        return Integer.parseInt(merged, 10);
+    }
+
+    /**
+     * Convert the string into its characters' ASCII codes.
+     * @param str input string
+     * @return
+     */
+    private int[] toAsciiCodes(String str) {
+        return str.chars()
+            .toArray();
+    }
+}

algorithms-miscellaneous-3/src/main/java/com/baeldung/folding/Main.java

@@ -0,0 +1,17 @@
+package com.baeldung.folding;
+
+/**
+ * Code snippet for article "A Guide to the Folding Technique".
+ *  
+ * @author A.Shcherbakov
+ *
+ */
+public class Main {
+
+    public static void main(String... arg) {
+        FoldingHash hasher = new FoldingHash();
+        final String str = "Java language";
+        System.out.println(hasher.hash(str, 2, 100_000));
+        System.out.println(hasher.hash(str, 3, 1_000));
+    }
+}

algorithms-miscellaneous-3/src/test/java/com/baeldung/algorithms/checksortedlist/SortedListCheckerUnitTest.java

@@ -0,0 +1,106 @@
+package com.baeldung.algorithms.checksortedlist;
+
+import static com.baeldung.algorithms.checksortedlist.SortedListChecker.checkIfSortedUsingComparators;
+import static com.baeldung.algorithms.checksortedlist.SortedListChecker.checkIfSortedUsingIterativeApproach;
+import static com.baeldung.algorithms.checksortedlist.SortedListChecker.checkIfSortedUsingOrderingClass;
+import static com.baeldung.algorithms.checksortedlist.SortedListChecker.checkIfSortedUsingRecursion;
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class SortedListCheckerUnitTest {
+
+    private List<String> sortedListOfString;
+    private List<String> unsortedListOfString;
+    private List<String> singletonList;
+
+    private List<Employee> employeesSortedByName;
+    private List<Employee> employeesNotSortedByName;
+
+    @Before
+    public void setUp() {
+        sortedListOfString = asList("Canada", "HK", "LA", "NJ", "NY");
+        unsortedListOfString = asList("LA", "HK", "NJ", "NY", "Canada");
+        singletonList = Collections.singletonList("NY");
+
+        employeesSortedByName = asList(new Employee(1L, "John"), new Employee(2L, "Kevin"), new Employee(3L, "Mike"));
+        employeesNotSortedByName = asList(new Employee(1L, "Kevin"), new Employee(2L, "John"), new Employee(3L, "Mike"));
+    }
+
+    @Test
+    public void givenSortedList_whenUsingIterativeApproach_thenReturnTrue() {
+        assertThat(checkIfSortedUsingIterativeApproach(sortedListOfString)).isTrue();
+    }
+
+    @Test
+    public void givenSingleElementList_whenUsingIterativeApproach_thenReturnTrue() {
+        assertThat(checkIfSortedUsingIterativeApproach(singletonList)).isTrue();
+    }
+
+    @Test
+    public void givenUnsortedList_whenUsingIterativeApproach_thenReturnFalse() {
+        assertThat(checkIfSortedUsingIterativeApproach(unsortedListOfString)).isFalse();
+    }
+
+    @Test
+    public void givenSortedListOfEmployees_whenUsingIterativeApproach_thenReturnTrue() {
+        assertThat(checkIfSortedUsingIterativeApproach(employeesSortedByName, Comparator.comparing(Employee::getName))).isTrue();
+    }
+
+    @Test
+    public void givenUnsortedListOfEmployees_whenUsingIterativeApproach_thenReturnFalse() {
+        assertThat(checkIfSortedUsingIterativeApproach(employeesNotSortedByName, Comparator.comparing(Employee::getName))).isFalse();
+    }
+
+    @Test
+    public void givenSortedList_whenUsingRecursion_thenReturnTrue() {
+        assertThat(checkIfSortedUsingRecursion(sortedListOfString)).isTrue();
+    }
+
+    @Test
+    public void givenSingleElementList_whenUsingRecursion_thenReturnTrue() {
+        assertThat(checkIfSortedUsingRecursion(singletonList)).isTrue();
+    }
+
+    @Test
+    public void givenUnsortedList_whenUsingRecursion_thenReturnFalse() {
+        assertThat(checkIfSortedUsingRecursion(unsortedListOfString)).isFalse();
+    }
+
+    @Test
+    public void givenSortedList_whenUsingGuavaOrdering_thenReturnTrue() {
+        assertThat(checkIfSortedUsingOrderingClass(sortedListOfString)).isTrue();
+    }
+
+    @Test
+    public void givenUnsortedList_whenUsingGuavaOrdering_thenReturnFalse() {
+        assertThat(checkIfSortedUsingOrderingClass(unsortedListOfString)).isFalse();
+    }
+
+    @Test
+    public void givenSortedListOfEmployees_whenUsingGuavaOrdering_thenReturnTrue() {
+        assertThat(checkIfSortedUsingOrderingClass(employeesSortedByName, Comparator.comparing(Employee::getName))).isTrue();
+    }
+
+    @Test
+    public void givenUnsortedListOfEmployees_whenUsingGuavaOrdering_thenReturnFalse() {
+        assertThat(checkIfSortedUsingOrderingClass(employeesNotSortedByName, Comparator.comparing(Employee::getName))).isFalse();
+    }
+
+    @Test
+    public void givenSortedList_whenUsingGuavaComparators_thenReturnTrue() {
+        assertThat(checkIfSortedUsingComparators(sortedListOfString)).isTrue();
+    }
+
+    @Test
+    public void givenUnsortedList_whenUsingGuavaComparators_thenReturnFalse() {
+        assertThat(checkIfSortedUsingComparators(unsortedListOfString)).isFalse();
+    }
+
+}

algorithms-miscellaneous-3/src/test/java/com/baeldung/algorithms/stringsortingbynumber/NaturalOrderComparatorsUnitTest.java

@@ -0,0 +1,79 @@
+package com.baeldung.algorithms.stringsortingbynumber;
+
+import com.baeldung.algorithms.stringsortingbynumber.NaturalOrderComparators;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class NaturalOrderComparatorsUnitTest {
+
+    @Test
+    public void givenSimpleStringsContainingIntsAndDoubles_whenSortedByRegex_checkSortingCorrect() {
+
+        List<String> testStrings = Arrays.asList("a1", "b3", "c4", "d2.2", "d2.4", "d2.3d");
+
+        testStrings.sort(NaturalOrderComparators.createNaturalOrderRegexComparator());
+
+        List<String> expected = Arrays.asList("a1", "d2.2", "d2.3d", "d2.4", "b3", "c4");
+
+        assertEquals(expected, testStrings);
+
+
+    }
+
+    @Test
+    public void givenSimpleStringsContainingIntsAndDoublesWithAnInvalidNumber_whenSortedByRegex_checkSortingCorrect() {
+
+        List<String> testStrings = Arrays.asList("a1", "b3", "c4", "d2.2", "d2.4", "d2.3.3d");
+
+        testStrings.sort(NaturalOrderComparators.createNaturalOrderRegexComparator());
+
+        List<String> expected = Arrays.asList("d2.3.3d", "a1", "d2.2", "d2.4", "b3", "c4");
+
+        assertEquals(expected, testStrings);
+
+
+    }
+
+    @Test
+    public void givenAllForseenProblems_whenSortedByRegex_checkSortingCorrect() {
+
+        List<String> testStrings = Arrays.asList("a1", "b3", "c4", "d2.2", "d2.f4", "d2.3.3d");
+
+        testStrings.sort(NaturalOrderComparators.createNaturalOrderRegexComparator());
+
+        List<String> expected = Arrays.asList("d2.3.3d", "a1", "d2.2", "d2.f4", "b3", "c4");
+
+        assertEquals(expected, testStrings);
+
+
+    }
+
+    @Test
+    public void givenComplexStringsContainingSeparatedNumbers_whenSortedByRegex_checkNumbersCondensedAndSorted() {
+
+        List<String> testStrings = Arrays.asList("a1b2c5", "b3ght3.2", "something65.thensomething5"); //125, 33.2, 65.5
+
+        List<String> expected = Arrays.asList("b3ght3.2", "something65.thensomething5", "a1b2c5" );
+
+        testStrings.sort(NaturalOrderComparators.createNaturalOrderRegexComparator());
+
+        assertEquals(expected, testStrings);
+
+    }
+
+    @Test
+    public void givenStringsNotContainingNumbers_whenSortedByRegex_checkOrderNotChanged() {
+
+        List<String> testStrings = Arrays.asList("a", "c", "d", "e");
+        List<String> expected = new ArrayList<>(testStrings);
+
+        testStrings.sort(NaturalOrderComparators.createNaturalOrderRegexComparator());
+
+        assertEquals(expected, testStrings);
+    }
+}

algorithms-miscellaneous-3/src/test/java/com/baeldung/folding/FoldingHashUnitTest.java

@@ -0,0 +1,54 @@
+package com.baeldung.folding;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class FoldingHashUnitTest {
+
+    @Test
+    public void givenStringJavaLanguage_whenSize2Capacity100000_then48933() throws Exception {
+        final FoldingHash hasher = new FoldingHash();
+        final int value = hasher.hash("Java language", 2, 100_000);
+        assertEquals(value, 48933);
+    }
+
+    @Test
+    public void givenStringVaJaLanguage_whenSize2Capacity100000_thenSameAsJavaLanguage() throws Exception {
+        final FoldingHash hasher = new FoldingHash();
+        final int java = hasher.hash("Java language", 2, 100_000);
+        final int vaja = hasher.hash("vaJa language", 2, 100_000);
+        assertTrue(java == vaja);
+    }
+
+    @Test
+    public void givenSingleElementArray_whenOffset0Size2_thenSingleElement() throws Exception {
+        final FoldingHash hasher = new FoldingHash();
+        final int[] value = hasher.extract(new int[] { 5 }, 0, 2);
+        assertArrayEquals(new int[] { 5 }, value);
+    }
+
+    @Test
+    public void givenFiveElementArray_whenOffset0Size3_thenFirstThreeElements() throws Exception {
+        final FoldingHash hasher = new FoldingHash();
+        final int[] value = hasher.extract(new int[] { 1, 2, 3, 4, 5 }, 0, 3);
+        assertArrayEquals(new int[] { 1, 2, 3 }, value);
+    }
+
+    @Test
+    public void givenFiveElementArray_whenOffset1Size2_thenTwoElements() throws Exception {
+        final FoldingHash hasher = new FoldingHash();
+        final int[] value = hasher.extract(new int[] { 1, 2, 3, 4, 5 }, 1, 2);
+        assertArrayEquals(new int[] { 2, 3 }, value);
+    }
+
+    @Test
+    public void givenFiveElementArray_whenOffset2SizeTooBig_thenElementsToTheEnd() throws Exception {
+        final FoldingHash hasher = new FoldingHash();
+        final int[] value = hasher.extract(new int[] { 1, 2, 3, 4, 5 }, 2, 2000);
+        assertArrayEquals(new int[] { 3, 4, 5 }, value);
+    }
+
+}

algorithms-sorting/src/main/java/com/baeldung/algorithms/shellsort/ShellSort.java

@@ -0,0 +1,20 @@
+package com.baeldung.algorithms.shellsort;
+
+public class ShellSort {
+
+    public static void sort(int arrayToSort[]) {
+        int n = arrayToSort.length;
+
+        for (int gap = n / 2; gap > 0; gap /= 2) {
+            for (int i = gap; i < n; i++) {
+                int key = arrayToSort[i];
+                int j = i;
+                while (j >= gap && arrayToSort[j - gap] > key) {
+                    arrayToSort[j] = arrayToSort[j - gap];
+                    j -= gap;
+                }
+                arrayToSort[j] = key;
+            }
+        }
+    }
+}

algorithms-sorting/src/test/java/com/baeldung/algorithms/shellsort/ShellSortUnitTest.java

@@ -0,0 +1,17 @@
+package com.baeldung.algorithms.shellsort;
+
+import static org.junit.Assert.*;
+import static org.junit.Assert.assertArrayEquals;
+
+import org.junit.Test;
+
+public class ShellSortUnitTest {
+
+    @Test
+    public void givenUnsortedArray_whenShellSort_thenSortedAsc() {
+        int[] input = {41, 15, 82, 5, 65, 19, 32, 43, 8};
+        ShellSort.sort(input);
+        int[] expected = {5, 8, 15, 19, 32, 41, 43, 65, 82};
+        assertArrayEquals("the two arrays are not equal", expected, input);
+    }
+}

apache-avro/pom.xml

@@ -17,7 +17,7 @@
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
-            <version>4.10</version>
+            <version>${junit.version}</version>
             <scope>test</scope>
         </dependency>
         <dependency>

apache-olingo/olingo2/pom.xml

@@ -3,37 +3,28 @@
 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 	<modelVersion>4.0.0</modelVersion>
-	<parent>
-		<groupId>org.springframework.boot</groupId>
-		<artifactId>spring-boot-starter-parent</artifactId>
-		<version>2.1.3.RELEASE</version>
-		<relativePath /> <!-- lookup parent from repository -->
-	</parent>
 	<groupId>org.baeldung.examples.olingo2</groupId>
 	<artifactId>olingo2-sample</artifactId>
 	<version>0.0.1-SNAPSHOT</version>
 	<name>olingo2-sample</name>
 	<description>Sample Olingo 2 Project</description>
 
-	<properties>
-		<java.version>1.8</java.version>
-		<olingo2.version>2.0.11</olingo2.version>
-	</properties>
+    <parent>
+        <artifactId>parent-boot-2</artifactId>
+        <groupId>com.baeldung</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../../parent-boot-2</relativePath>
+    </parent>
 
 	<dependencies>
-
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-jersey</artifactId>
 		</dependency>
-
-
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-data-jpa</artifactId>
 		</dependency>
-
-
 		<dependency>
 			<groupId>com.h2database</groupId>
 			<artifactId>h2</artifactId>
@@ -90,4 +81,8 @@
 		</plugins>
 	</build>
 
+	<properties>
+		<olingo2.version>2.0.11</olingo2.version>
+	</properties>
+
 </project>

apache-olingo/olingo2/src/test/java/org/baeldung/examples/olingo2/Olingo2SampleApplicationUnitTest.java

@@ -7,7 +7,7 @@ import org.springframework.test.context.junit4.SpringRunner;
 
 @RunWith(SpringRunner.class)
 @SpringBootTest
-public class Olingo2SampleApplicationTests {
+public class Olingo2SampleApplicationUnitTest {
 
 	@Test
 	public void contextLoads() {

apache-pulsar/pom.xml

@@ -7,6 +7,13 @@
     <version>0.0.1</version>
     <name>apache-pulsar</name>
 
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>..</relativePath>
+    </parent>
+
     <dependencies>
         <dependency>
             <groupId>org.apache.pulsar</groupId>

apache-pulsar/src/main/java/com/baeldung/ConsumerUnitTest.java

@@ -7,7 +7,7 @@ import org.apache.pulsar.client.api.Message;
 import org.apache.pulsar.client.api.PulsarClient;
 import org.apache.pulsar.client.api.SubscriptionType;
 
-public class ConsumerTest {
+public class ConsumerUnitTest {
 
     private static final String SERVICE_URL = "pulsar://localhost:6650";
     private static final String TOPIC_NAME = "test-topic";

apache-pulsar/src/main/java/com/baeldung/ProducerUnitTest.java

@@ -11,7 +11,7 @@ import org.apache.pulsar.client.api.PulsarClientException;
 import java.io.IOException;
 import java.util.stream.IntStream;
 
-public class ProducerTest {
+public class ProducerUnitTest {
 
     private static final String SERVICE_URL = "pulsar://localhost:6650";
     private static final String TOPIC_NAME = "test-topic";

apache-pulsar/src/main/java/com/baeldung/subscriptions/ExclusiveSubscriptionUnitTest.java

@@ -10,7 +10,7 @@ import org.apache.pulsar.client.api.SubscriptionType;
 
 import java.util.stream.IntStream;
 
-public class ExclusiveSubscriptionTest {
+public class ExclusiveSubscriptionUnitTest {
     private static final String SERVICE_URL = "pulsar://localhost:6650";
     private static final String TOPIC_NAME = "test-topic";
     private static final String SUBSCRIPTION_NAME = "test-subscription";

apache-pulsar/src/main/java/com/baeldung/subscriptions/FailoverSubscriptionUnitTest.java

@@ -11,7 +11,7 @@ import org.apache.pulsar.client.api.SubscriptionType;
 
 import java.util.stream.IntStream;
 
-public class FailoverSubscriptionTest {
+public class FailoverSubscriptionUnitTest {
     private static final String SERVICE_URL = "pulsar://localhost:6650";
     private static final String TOPIC_NAME = "failover-subscription-test-topic";
     private static final String SUBSCRIPTION_NAME = "test-subscription";

apache-spark/pom.xml

@@ -49,6 +49,7 @@
 			<version>${com.datastax.spark.spark-cassandra-connector-java.version}</version>
 		</dependency>
     </dependencies>
+
 	<build>
     	<plugins>
     	  	<plugin>
@@ -78,6 +79,7 @@
       		</plugin>
    		</plugins>
   	</build>
+
     <properties>
         <org.apache.spark.spark-core.version>2.3.0</org.apache.spark.spark-core.version>
         <org.apache.spark.spark-sql.version>2.3.0</org.apache.spark.spark-sql.version>

autovalue/README.md

@@ -1,3 +1,4 @@
 ### Relevant Articles:
 - [Introduction to AutoValue](http://www.baeldung.com/introduction-to-autovalue)
 - [Introduction to AutoFactory](http://www.baeldung.com/autofactory)
+- [Google AutoService](https://www.baeldung.com/google-autoservice)

autovalue/pom.xml

@@ -29,6 +29,12 @@
                 </exclusion>
             </exclusions>
         </dependency>
+        <dependency>
+            <groupId>com.google.auto.service</groupId>
+            <artifactId>auto-service</artifactId>
+            <version>${auto-service.version}</version>
+            <optional>true</optional>
+        </dependency>
 
         <dependency>
             <groupId>com.google.inject</groupId>
@@ -40,6 +46,7 @@
     <properties>
         <auto-value.version>1.3</auto-value.version>
         <auto-factory.version>1.0-beta5</auto-factory.version>
+        <auto-service.version>1.0-rc5</auto-service.version>
         <guice.version>4.2.0</guice.version>
     </properties>
 

autovalue/src/main/java/com/baeldung/autoservice/BingTranslationServiceProvider.java

@@ -0,0 +1,14 @@
+package com.baeldung.autoservice;
+
+import com.google.auto.service.AutoService;
+
+import java.util.Locale;
+
+@AutoService(TranslationService.class)
+public class BingTranslationServiceProvider implements TranslationService {
+    @Override
+    public String translate(String message, Locale from, Locale to) {
+        // implementation details
+        return message + " (translated by Bing)"; 
+    }
+}

autovalue/src/main/java/com/baeldung/autoservice/GoogleTranslationServiceProvider.java

@@ -0,0 +1,14 @@
+package com.baeldung.autoservice;
+
+import com.google.auto.service.AutoService;
+
+import java.util.Locale;
+
+@AutoService(TranslationService.class)
+public class GoogleTranslationServiceProvider implements TranslationService {
+    @Override
+    public String translate(String message, Locale from, Locale to) {
+        // implementation details
+        return message + " (translated by Google)"; 
+    }
+}

autovalue/src/main/java/com/baeldung/autoservice/TranslationService.java

@@ -0,0 +1,7 @@
+package com.baeldung.autoservice;
+
+import java.util.Locale;
+
+public interface TranslationService {
+    String translate(String message, Locale from, Locale to);
+}

autovalue/src/test/java/com/baeldung/autoservice/TranslationServiceUnitTest.java

@@ -0,0 +1,37 @@
+package com.baeldung.autoservice;
+
+import com.baeldung.autoservice.TranslationService;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ServiceLoader;
+import java.util.stream.StreamSupport;
+
+import static org.junit.Assert.assertEquals;
+
+public class TranslationServiceUnitTest {
+
+    private ServiceLoader<TranslationService> loader;
+
+    @Before
+    public void setUp() {
+        loader = ServiceLoader.load(TranslationService.class);
+    }
+
+    @Test
+    public void whenServiceLoaderLoads_thenLoadsAllProviders() {
+        long count = StreamSupport.stream(loader.spliterator(), false).count();
+        assertEquals(2, count);
+    }
+
+    @Test
+    public void whenServiceLoaderLoadsGoogleService_thenGoogleIsLoaded() {
+        TranslationService googleService = StreamSupport.stream(loader.spliterator(), false)
+          .filter(p -> p.getClass().getSimpleName().equals("GoogleTranslationServiceProvider"))
+          .findFirst()
+          .get();
+		
+        String message = "message";
+        assertEquals(message + " (translated by Google)", googleService.translate(message, null, null));
+    }
+}