Merge branch 'master' into custom-filter-update

README.md

@@ -40,5 +40,3 @@ This tutorials project is being built **[>> HERE](https://rest-security.ci.cloud
 - [Apache Maven Standard Directory Layout](http://www.baeldung.com/maven-directory-structure)
 - [Apache Maven Tutorial](http://www.baeldung.com/maven)
 - [Designing a User Friendly Java Library](http://www.baeldung.com/design-a-user-friendly-java-library)
-- [Java Service Provider Interface](http://www.baeldung.com/java-spi)
-- [Java Streams vs Vavr Streams](http://www.baeldung.com/vavr-java-streams)

algorithms/src/main/java/com/baeldung/algorithms/mcts/tictactoe/Board.java

@@ -148,7 +148,7 @@ public class Board {
             System.out.println("Game Draw");
             break;
         case IN_PROGRESS:
-            System.out.println("Game In rogress");
+            System.out.println("Game In Progress");
             break;
         }
     }

algorithms/src/test/java/com/baeldung/algorithms/analysis/AnalysisRunnerLiveTest.java

@@ -0,0 +1,139 @@
+package com.baeldung.algorithms.analysis;
+
+import org.junit.Test;
+
+public class AnalysisRunnerLiveTest {
+
+    int n = 10;
+    int total = 0;
+
+    @Test
+    public void whenConstantComplexity_thenConstantRuntime() {
+
+        System.out.println("**** n = " + n + " ****");
+        System.out.println();
+
+        // Constant Time
+        System.out.println("**** Constant time ****");
+
+        System.out.println("Hey - your input is: " + n);
+        System.out.println("Running time not dependent on input size!");
+        System.out.println();
+    }
+
+    @Test
+    public void whenLogarithmicComplexity_thenLogarithmicRuntime() {
+        // Logarithmic Time
+        System.out.println("**** Logarithmic Time ****");
+        for (int i = 1; i < n; i = i * 2) {
+            // System.out.println("Hey - I'm busy looking at: " + i);
+            total++;
+        }
+        System.out.println("Total amount of times run: " + total);
+        System.out.println();
+    }
+
+    @Test
+    public void whenLinearComplexity_thenLinearRuntime() {
+        // Linear Time
+        System.out.println("**** Linear Time ****");
+        for (int i = 0; i < n; i++) {
+            // System.out.println("Hey - I'm busy looking at: " + i);
+            total++;
+        }
+        System.out.println("Total amount of times run: " + total);
+        System.out.println();
+
+    }
+
+    @Test
+    public void whenNLogNComplexity_thenNLogNRuntime() {
+        // N Log N Time
+        System.out.println("**** nlogn Time ****");
+        total = 0;
+        for (
+
+            int i = 1; i <= n; i++) {
+            for (int j = 1; j < n; j = j * 2) {
+                // System.out.println("Hey - I'm busy looking at: " + i + " and " + j);
+                total++;
+            }
+        }
+        System.out.println("Total amount of times run: " + total);
+        System.out.println();
+    }
+
+    @Test
+    public void whenQuadraticComplexity_thenQuadraticRuntime() {
+        // Quadratic Time
+        System.out.println("**** Quadratic Time ****");
+        total = 0;
+        for (
+
+            int i = 1; i <= n; i++) {
+            for (int j = 1; j <= n; j++) {
+                // System.out.println("Hey - I'm busy looking at: " + i + " and " + j);
+                total++;
+            }
+        }
+        System.out.println("Total amount of times run: " + total);
+        System.out.println();
+    }
+
+    @Test
+    public void whenCubicComplexity_thenCubicRuntime() {
+        // Cubic Time
+        System.out.println("**** Cubic Time ****");
+        total = 0;
+        for (
+
+            int i = 1; i <= n; i++) {
+            for (int j = 1; j <= n; j++) {
+                for (int k = 1; k <= n; k++) {
+                    // System.out.println("Hey - I'm busy looking at: " + i + " and " + j + " and " + k);
+                    total++;
+                }
+            }
+        }
+        System.out.println("Total amount of times run: " + total);
+        System.out.println();
+    }
+
+    @Test
+    public void whenExponentialComplexity_thenExponentialRuntime() {
+        // Exponential Time
+        System.out.println("**** Exponential Time ****");
+        total = 0;
+        for (
+
+            int i = 1; i <= Math.pow(2, n); i++) {
+            // System.out.println("Hey - I'm busy looking at: " + i);
+            total++;
+        }
+        System.out.println("Total amount of times run: " + total);
+        System.out.println();
+    }
+
+    @Test
+    public void whenFactorialComplexity_thenFactorialRuntime() {
+        // Factorial Time
+        System.out.println("**** Factorial Time ****");
+        total = 0;
+        for (
+
+            int i = 1; i <=
+
+            factorial(n); i++) {
+            // System.out.println("Hey - I'm busy looking at: " + i);
+            total++;
+        }
+        System.out.println("Total amount of times run: " + total);
+    }
+
+    static int factorial(int n) {
+        if (n == 0 || n == 1)
+            return 1;
+        else
+            return n * factorial(n - 1);
+    }
+}

animal-sniffer-mvn-plugin/pom.xml

@@ -5,7 +5,7 @@
     <artifactId>animal-sniffer-mvn-plugin</artifactId>
     <packaging>jar</packaging>
     <version>1.0-SNAPSHOT</version>
-    <name>example-animal-sniffer-mvn-plugin</name>
+    <name>animal-sniffer-mvn-plugin</name>
     <url>http://maven.apache.org</url>
 
     <parent>

apache-cayenne/src/test/java/com/baeldung/apachecayenne/CayenneAdvancedOperationLiveTest.java

@@ -19,7 +19,7 @@ import java.util.List;
 import static junit.framework.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 
-public class CayenneAdvancedOperationIntegrationTest {
+public class CayenneAdvancedOperationLiveTest {
     private static ObjectContext context = null;
 
     @BeforeClass

apache-cayenne/src/test/java/com/baeldung/apachecayenne/CayenneOperationLiveTest.java

@@ -16,7 +16,7 @@ import static junit.framework.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 
 
-public class CayenneOperationIntegrationTest {
+public class CayenneOperationLiveTest {
     private static ObjectContext context = null;
 
     @BeforeClass

apache-poi/src/test/java/com/baeldung/poi/powerpoint/PowerPointIntegrationTest.java

@@ -1,25 +1,30 @@
 package com.baeldung.poi.powerpoint;
 
+import java.io.File;
+import java.util.List;
+
 import org.apache.poi.xslf.usermodel.XMLSlideShow;
 import org.apache.poi.xslf.usermodel.XSLFShape;
 import org.apache.poi.xslf.usermodel.XSLFSlide;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
-
-import java.io.File;
-import java.util.List;
+import org.junit.rules.TemporaryFolder;
 
 public class PowerPointIntegrationTest {
 
     private PowerPointHelper pph;
     private String fileLocation;
     private static final String FILE_NAME = "presentation.pptx";
+    
+    @Rule
+    public TemporaryFolder tempFolder = new TemporaryFolder();
 
     @Before
     public void setUp() throws Exception {
-        File currDir = new File(".");
+        File currDir = tempFolder.newFolder();
         String path = currDir.getAbsolutePath();
         fileLocation = path.substring(0, path.length() - 1) + FILE_NAME;
 

azure/src/test/java/com/baeldung/springboot/azure/AzureApplicationIntegrationTest.java

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

camel-api/pom.xml

@@ -5,7 +5,6 @@
     <groupId>com.example</groupId>
     <artifactId>spring-boot-camel</artifactId>
     <version>0.0.1-SNAPSHOT</version>
-    <name>Spring-Boot - Camel API</name>
 
     <parent>
         <groupId>com.baeldung</groupId>

core-java-8/README.md

@@ -52,4 +52,4 @@
 - [Measure Elapsed Time in Java](http://www.baeldung.com/java-measure-elapsed-time)
 - [Java Optional – orElse() vs orElseGet()](http://www.baeldung.com/java-optional-or-else-vs-or-else-get)
 - [An Introduction to Java.util.Hashtable Class](http://www.baeldung.com/java-hash-table)
-
+- [Method Parameter Reflection in Java](http://www.baeldung.com/java-parameter-reflection)

core-java-8/pom.xml

@@ -195,6 +195,16 @@
                     </execution>
                 </executions>
             </plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<version>3.1</version>
+				<configuration>
+					<source>1.8</source>
+					<target>1.8</target>
+					<compilerArgument>-parameters</compilerArgument>
+				</configuration>
+			</plugin>
             <plugin>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-maven-plugin</artifactId>

core-java-8/src/main/java/com/baeldung/reflect/Person.java

@@ -0,0 +1,18 @@
+package com.baeldung.reflect;
+
+public class Person {
+
+	private String fullName;
+
+	public Person(String fullName) {
+		this.fullName = fullName;
+	}
+
+	public void setFullName(String fullName) {
+		this.fullName = fullName;
+	}
+
+	public String getFullName() {
+		return fullName;
+	}
+}

core-java-8/src/test/java/com/baeldung/java8/UnsignedArithmeticUnitTest.java

@@ -0,0 +1,60 @@
+package com.baeldung.java8;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.catchThrowable;
+import static org.junit.Assert.assertEquals;
+
+public class UnsignedArithmeticUnitTest {
+    @Test
+    public void whenDoublingALargeByteNumber_thenOverflow() {
+        byte b1 = 100;
+        byte b2 = (byte) (b1 << 1);
+
+        assertEquals(-56, b2);
+    }
+
+    @Test
+    public void whenComparingNumbers_thenNegativeIsInterpretedAsUnsigned() {
+        int positive = Integer.MAX_VALUE;
+        int negative = Integer.MIN_VALUE;
+
+        int signedComparison = Integer.compare(positive, negative);
+        assertEquals(1, signedComparison);
+
+        int unsignedComparison = Integer.compareUnsigned(positive, negative);
+        assertEquals(-1, unsignedComparison);
+
+        assertEquals(negative, positive + 1);
+    }
+
+    @Test
+    public void whenDividingNumbers_thenNegativeIsInterpretedAsUnsigned() {
+        int positive = Integer.MAX_VALUE;
+        int negative = Integer.MIN_VALUE;
+
+        assertEquals(-1, negative / positive);
+        assertEquals(1, Integer.divideUnsigned(negative, positive));
+
+        assertEquals(-1, negative % positive);
+        assertEquals(1, Integer.divideUnsigned(negative, positive));
+    }
+
+    @Test
+    public void whenParsingNumbers_thenNegativeIsInterpretedAsUnsigned() {
+        Throwable thrown = catchThrowable(() -> Integer.parseInt("2147483648"));
+        assertThat(thrown).isInstanceOf(NumberFormatException.class);
+
+        assertEquals(Integer.MAX_VALUE + 1, Integer.parseUnsignedInt("2147483648"));
+    }
+
+    @Test
+    public void whenFormattingNumbers_thenNegativeIsInterpretedAsUnsigned() {
+        String signedString = Integer.toString(Integer.MIN_VALUE);
+        assertEquals("-2147483648", signedString);
+
+        String unsignedString = Integer.toUnsignedString(Integer.MIN_VALUE);
+        assertEquals("2147483648", unsignedString);
+    }
+}

core-java-8/src/test/java/com/baeldung/reflect/MethodParamNameUnitTest.java

@@ -0,0 +1,34 @@
+package com.baeldung.reflect;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.lang.reflect.Parameter;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+import org.junit.Test;
+
+public class MethodParamNameUnitTest {
+
+    @Test
+    public void whenGetConstructorParams_thenOk() 
+    		throws NoSuchMethodException, SecurityException {
+    	List<Parameter> parameters 
+    		= Arrays.asList(Person.class.getConstructor(String.class).getParameters());
+    	Optional<Parameter> parameter 
+    		= parameters.stream().filter(Parameter::isNamePresent).findFirst();
+    	assertThat(parameter.get().getName()).isEqualTo("fullName");  
+    }
+
+    @Test
+    public void whenGetMethodParams_thenOk() 
+    		throws NoSuchMethodException, SecurityException {
+    	List<Parameter> parameters 
+    		= Arrays.asList(
+    			Person.class.getMethod("setFullName", String.class).getParameters());
+    	Optional<Parameter> parameter 
+			= parameters.stream().filter(Parameter::isNamePresent).findFirst();
+    	assertThat(parameter.get().getName()).isEqualTo("fullName");
+    }
+}

core-java-8/src/test/java/com/baeldung/typeinference/TypeInferenceUnitTest.java

@@ -0,0 +1,87 @@
+package com.baeldung.typeinference;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Test;
+
+public class TypeInferenceUnitTest {
+
+    @Test
+    public void givenNoTypeInference_whenInvokingGenericMethodsWithTypeParameters_ObjectsAreCreated() {
+        // Without type inference. code is verbose.
+        Map<String, Map<String, String>> mapOfMaps = new HashMap<String, Map<String, String>>();
+        List<String> strList = Collections.<String> emptyList();
+        List<Integer> intList = Collections.<Integer> emptyList();
+
+        assertTrue(mapOfMaps.isEmpty());
+        assertTrue(strList.isEmpty());
+        assertTrue(intList.isEmpty());
+    }
+
+    @Test
+    public void givenTypeInference_whenInvokingGenericMethodsWithoutTypeParameters_ObjectsAreCreated() {
+        // With type inference. code is concise.
+        List<String> strListInferred = Collections.emptyList();
+        List<Integer> intListInferred = Collections.emptyList();
+
+        assertTrue(strListInferred.isEmpty());
+        assertTrue(intListInferred.isEmpty());
+    }
+
+    @Test
+    public void givenJava7_whenInvokingCostructorWithoutTypeParameters_ObjectsAreCreated() {
+        // Type Inference for constructor using diamond operator.
+        Map<String, Map<String, String>> mapOfMapsInferred = new HashMap<>();
+
+        assertTrue(mapOfMapsInferred.isEmpty());
+        assertEquals("public class java.util.HashMap<K,V>", mapOfMapsInferred.getClass()
+            .toGenericString());
+    }
+
+    static <T> List<T> add(List<T> list, T a, T b) {
+        list.add(a);
+        list.add(b);
+        return list;
+    }
+
+    @Test
+    public void givenGenericMethod_WhenInvokedWithoutExplicitTypes_TypesAreInferred() {
+        // Generalized target-type inference
+        List<String> strListGeneralized = add(new ArrayList<>(), "abc", "def");
+        List<Integer> intListGeneralized = add(new ArrayList<>(), 1, 2);
+        List<Number> numListGeneralized = add(new ArrayList<>(), 1, 2.0);
+
+        assertEquals("public class java.util.ArrayList<E>", strListGeneralized.getClass()
+            .toGenericString());
+        assertFalse(intListGeneralized.isEmpty());
+        assertEquals(2, numListGeneralized.size());
+    }
+
+    @Test
+    public void givenLambdaExpressions_whenParameterTypesNotSpecified_ParameterTypesAreInferred() {
+        // Type Inference and Lambda Expressions.
+        List<Integer> intList = Arrays.asList(5, 3, 4, 2, 1);
+        Collections.sort(intList, (a, b) -> {
+            assertEquals("java.lang.Integer", a.getClass().getName());
+            return a.compareTo(b);
+        });
+        assertEquals("[1, 2, 3, 4, 5]", Arrays.toString(intList.toArray()));
+
+        List<String> strList = Arrays.asList("Red", "Blue", "Green");
+        Collections.sort(strList, (a, b) -> {
+            assertEquals("java.lang.String", a.getClass().getName());
+            return a.compareTo(b);
+        });
+        assertEquals("[Blue, Green, Red]", Arrays.toString(strList.toArray()));
+    }
+
+}

core-java-9/README.md

@@ -25,3 +25,4 @@
 - [Introduction to Chronicle Queue](http://www.baeldung.com/java-chronicle-queue)
 - [A Guide to Java 9 Modularity](http://www.baeldung.com/java-9-modularity)
 - [Optional orElse Optional](http://www.baeldung.com/java-optional-or-else-optional)
+- [Java 9 java.lang.Module API](http://www.baeldung.com/java-9-module-api)

core-java-io/src/test/java/com/baeldung/file/FilesManualTest.java

@@ -77,6 +77,6 @@ public class FilesManualTest {
         bw.newLine();
         bw.close();
 
-        assertThat(StreamUtils.getStringFromInputStream(new FileInputStream(fileName))).isEqualTo("UK\r\n" + "US\r\n" + "Germany\r\n" + "Spain\n");
+        assertThat(StreamUtils.getStringFromInputStream(new FileInputStream(fileName))).isEqualTo("UK\r\n" + "US\r\n" + "Germany\r\n" + "Spain\r\n");
     }
 }

core-java-io/src/test/java/org/baeldung/java/io/JavaReadFromFileUnitTest.java

@@ -1,6 +1,7 @@
 package org.baeldung.java.io;
 
 import org.junit.Test;
+import org.junit.Ignore;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -105,8 +106,9 @@ public class JavaReadFromFileUnitTest {
     }
 
     @Test
+    @Ignore // TODO
     public void whenReadUTFEncodedFile_thenCorrect() throws IOException {
-        final String expected_value = "é<EFBFBD>’空";
+        final String expected_value = "青空";
         final BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("src/test/resources/test_read7.in"), "UTF-8"));
         final String currentLine = reader.readLine();
         reader.close();

core-java/README.md

@@ -141,6 +141,7 @@
 - [Java KeyStore API](http://www.baeldung.com/java-keystore)
 - [Double-Checked Locking with Singleton](http://www.baeldung.com/java-singleton-double-checked-locking)
 - [Guide to Java Clock Class](http://www.baeldung.com/java-clock)
+- [Infinite Loops in Java](http://www.baeldung.com/infinite-loops-java)
 - [Using Java Assertions](http://www.baeldung.com/java-assert)
 - [Pass-By-Value as a Parameter Passing Mechanism in Java](http://www.baeldung.com/java-pass-by-value-or-pass-by-reference)
 - [Check If a String Is Numeric in Java](http://www.baeldung.com/java-check-string-number)
@@ -149,5 +150,13 @@
 - [NaN in Java](http://www.baeldung.com/java-not-a-number)
 - [Infinite Loops in Java](http://www.baeldung.com/infinite-loops-java)
 - [Why Use char[] Array Over a String for Storing Passwords in Java?](http://www.baeldung.com/java-storing-passwords)
-
-
+- [Introduction to Creational Design Patterns](http://www.baeldung.com/creational-design-patterns)
+- [Proxy, Decorator, Adapter and Bridge Patterns](http://www.baeldung.com/java-structural-design-patterns)
+- [Singletons in Java](http://www.baeldung.com/java-singleton)
+- [Flyweight Pattern in Java](http://www.baeldung.com/java-flyweight)
+- [The Observer Pattern in Java](http://www.baeldung.com/java-observer-pattern)
+- [Service Locator Pattern](http://www.baeldung.com/java-service-locator-pattern)
+- [The Thread.join() Method in Java](http://www.baeldung.com/java-thread-join)
+- [Guide to the super Java Keyword](http://www.baeldung.com/java-super)
+- [Guide to the this Java Keyword](http://www.baeldung.com/java-this)
+- [Jagged Arrays In Java](http://www.baeldung.com/java-jagged-arrays)

core-java/src/main/java/com/baeldung/array/JaggedArray.java

@@ -0,0 +1,49 @@
+package com.baeldung.array;
+
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class JaggedArray {
+
+    int[][] shortHandFormInitialization() {
+        int[][] jaggedArr = { { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } };
+        return jaggedArr;
+    }
+
+    int[][] declarationAndThenInitialization() {
+        int[][] jaggedArr = new int[3][];
+        jaggedArr[0] = new int[] { 1, 2 };
+        jaggedArr[1] = new int[] { 3, 4, 5 };
+        jaggedArr[2] = new int[] { 6, 7, 8, 9 };
+        return jaggedArr;
+    }
+
+    int[][] declarationAndThenInitializationUsingUserInputs() {
+        int[][] jaggedArr = new int[3][];
+        jaggedArr[0] = new int[2];
+        jaggedArr[1] = new int[3];
+        jaggedArr[2] = new int[4];
+        initializeElements(jaggedArr);
+        return jaggedArr;
+    }
+
+    void initializeElements(int[][] jaggedArr) {
+        Scanner sc = new Scanner(System.in);
+        for (int outer = 0; outer < jaggedArr.length; outer++) {
+            for (int inner = 0; inner < jaggedArr[outer].length; inner++) {
+                jaggedArr[outer][inner] = sc.nextInt();
+            }
+        }
+    }
+
+    void printElements(int[][] jaggedArr) {
+        for (int index = 0; index < jaggedArr.length; index++) {
+            System.out.println(Arrays.toString(jaggedArr[index]));
+        }
+    }
+
+    int[] getElementAtGivenIndex(int[][] jaggedArr, int index) {
+        return jaggedArr[index];
+    }
+
+}

core-java/src/main/java/com/baeldung/linkedlist/LinkedList.java

@@ -1,58 +0,0 @@
-package com.baeldung.linkedlist;
-
-/**
- * Implementation of a singly linked list.
- */
-public class LinkedList {
-    private Node head;
-    private Node tail;
-
-    public Node head() {
-        return head;
-    }
-
-    public void add(String data) {
-        Node newNode = new Node(data);
-
-        if (head == null) {
-            head = newNode;
-            tail = newNode;
-        } else {
-            tail.next = newNode;
-            tail = newNode;
-        }
-    }
-
-    public static class Node {
-        private Node next;
-        private String data;
-
-        public Node(String data) {
-            this.data = data;
-        }
-
-        public String data() {
-            return data;
-        }
-
-        public void setData(String data) {
-            this.data = data;
-        }
-        
-        public boolean hasNext() {
-            return next != null;
-        }
-
-        public Node next() {
-            return next;
-        }
-
-        public void setNext(Node next) {
-            this.next = next;
-        }
-
-        public String toString() {
-            return this.data;
-        }
-    }
-}

core-java/src/main/java/com/baeldung/linkedlist/MiddleElementLookup.java

@@ -1,12 +1,23 @@
 package com.baeldung.linkedlist;
 
-import com.baeldung.linkedlist.LinkedList.Node;
+import java.util.LinkedList;
+import java.util.Optional;
+
+import com.baeldung.linkedlist.Node;
 
 public class MiddleElementLookup {
 
-    public static String findMiddleElement(Node head) {
+    public static Optional<String> findMiddleElementLinkedList(LinkedList<String> linkedList) {
+        if (linkedList == null || linkedList.isEmpty()) {
+            return Optional.empty();
+        }
+
+        return Optional.ofNullable(linkedList.get((linkedList.size() - 1) / 2));
+    }
+
+    public static Optional<String> findMiddleElementFromHead(Node head) {
         if (head == null) {
-            return null;
+            return Optional.empty();
         }
 
         // calculate the size of the list
@@ -23,17 +34,17 @@ public class MiddleElementLookup {
             current = current.next();
         }
 
-        return current.data();
+        return Optional.ofNullable(current.data());
     }
 
-    public static String findMiddleElement1PassRecursively(Node head) {
+    public static Optional<String> findMiddleElementFromHead1PassRecursively(Node head) {
         if (head == null) {
-            return null;
+            return Optional.empty();
         }
 
         MiddleAuxRecursion middleAux = new MiddleAuxRecursion();
         findMiddleRecursively(head, middleAux);
-        return middleAux.middle.data();
+        return Optional.ofNullable(middleAux.middle.data());
     }
 
     private static void findMiddleRecursively(Node node, MiddleAuxRecursion middleAux) {
@@ -53,9 +64,9 @@ public class MiddleElementLookup {
         middleAux.length--;
     }
 
-    public static String findMiddleElement1PassIteratively(Node head) {
+    public static Optional<String> findMiddleElementFromHead1PassIteratively(Node head) {
         if (head == null) {
-            return null;
+            return Optional.empty();
         }
 
         Node slowPointer = head;
@@ -68,7 +79,7 @@ public class MiddleElementLookup {
             slowPointer = slowPointer.next();
         }
 
-        return slowPointer.data();
+        return Optional.ofNullable(slowPointer.data());
     }
 
     private static class MiddleAuxRecursion {

core-java/src/main/java/com/baeldung/linkedlist/Node.java

@@ -0,0 +1,34 @@
+package com.baeldung.linkedlist;
+
+public class Node {
+    private Node next;
+    private String data;
+
+    public Node(String data) {
+        this.data = data;
+    }
+
+    public String data() {
+        return data;
+    }
+
+    public void setData(String data) {
+        this.data = data;
+    }
+
+    public boolean hasNext() {
+        return next != null;
+    }
+
+    public Node next() {
+        return next;
+    }
+
+    public void setNext(Node next) {
+        this.next = next;
+    }
+
+    public String toString() {
+        return this.data;
+    }
+}

core-java/src/test/java/com/baeldung/array/JaggedArrayUnitTest.java

@@ -0,0 +1,53 @@
+package com.baeldung.array;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.io.PrintStream;
+
+import org.junit.Test;
+
+public class JaggedArrayUnitTest {
+
+    private JaggedArray obj = new JaggedArray();
+
+    @Test
+    public void whenInitializedUsingShortHandForm_thenCorrect() {
+        assertArrayEquals(new int[][] { { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } }, obj.shortHandFormInitialization());
+    }
+
+    @Test
+    public void whenInitializedWithDeclarationAndThenInitalization_thenCorrect() {
+        assertArrayEquals(new int[][] { { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } }, obj.declarationAndThenInitialization());
+    }
+
+    @Test
+    public void whenInitializedWithDeclarationAndThenInitalizationUsingUserInputs_thenCorrect() {
+        InputStream is = new ByteArrayInputStream("1 2 3 4 5 6 7 8 9".getBytes());
+        System.setIn(is);
+        assertArrayEquals(new int[][] { { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } }, obj.declarationAndThenInitializationUsingUserInputs());
+        System.setIn(System.in);
+    }
+
+    @Test
+    public void givenJaggedArrayAndAnIndex_thenReturnArrayAtGivenIndex() {
+        int[][] jaggedArr = { { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } };
+        assertArrayEquals(new int[] { 1, 2 }, obj.getElementAtGivenIndex(jaggedArr, 0));
+        assertArrayEquals(new int[] { 3, 4, 5 }, obj.getElementAtGivenIndex(jaggedArr, 1));
+        assertArrayEquals(new int[] { 6, 7, 8, 9 }, obj.getElementAtGivenIndex(jaggedArr, 2));
+    }
+
+    @Test
+    public void givenJaggedArray_whenUsingArraysAPI_thenVerifyPrintedElements() {
+        int[][] jaggedArr = { { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } };
+        ByteArrayOutputStream outContent = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(outContent));
+        obj.printElements(jaggedArr);
+        assertEquals("[1, 2][3, 4, 5][6, 7, 8, 9]", outContent.toString().replace("\r", "").replace("\n", ""));
+        System.setOut(System.out);
+    }
+
+}

core-java/src/test/java/com/baeldung/arrays/ArraysUnitTest.java

@@ -0,0 +1,153 @@
+package com.baeldung.arrays;
+
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Stream;
+
+public class ArraysUnitTest {
+    private String[] intro;
+
+    @Rule
+    public final ExpectedException exception = ExpectedException.none();
+
+    @Before
+    public void setup() {
+        intro = new String[] { "once", "upon", "a", "time" };
+    }
+
+    @Test
+    public void whenCopyOfRange_thenAbridgedArray() {
+        String[] abridgement = Arrays.copyOfRange(intro, 0, 3);
+
+        assertArrayEquals(new String[] { "once", "upon", "a" }, abridgement);
+        assertFalse(Arrays.equals(intro, abridgement));
+    }
+
+    @Test
+    public void whenCopyOf_thenNullElement() {
+        String[] revised = Arrays.copyOf(intro, 3);
+        String[] expanded = Arrays.copyOf(intro, 5);
+
+        assertArrayEquals(Arrays.copyOfRange(intro, 0, 3), revised);
+        assertNull(expanded[4]);
+    }
+
+    @Test
+    public void whenFill_thenAllMatch() {
+        String[] stutter = new String[3];
+        Arrays.fill(stutter, "once");
+
+        assertTrue(Stream.of(stutter).allMatch(el -> "once".equals(el)));
+    }
+
+    @Test
+    public void whenEqualsContent_thenMatch() {
+        assertTrue(Arrays.equals(new String[] { "once", "upon", "a", "time" }, intro));
+        assertFalse(Arrays.equals(new String[] { "once", "upon", "a", null }, intro));
+    }
+
+    @Test
+    public void whenNestedArrays_thenDeepEqualsPass() {
+        String[] end = { "the", "end" };
+        Object[] story = new Object[] { intro, new String[] { "chapter one", "chapter two" }, end };
+        Object[] copy = new Object[] { intro, new String[] { "chapter one", "chapter two" }, end };
+
+        assertTrue(Arrays.deepEquals(story, copy));
+        assertFalse(Arrays.equals(story, copy));
+    }
+
+    @Test
+    public void whenSort_thenArraySorted() {
+        String[] sorted = Arrays.copyOf(intro, 4);
+        Arrays.sort(sorted);
+
+        assertArrayEquals(new String[] { "a", "once", "time", "upon" }, sorted);
+    }
+
+    @Test
+    public void whenBinarySearch_thenFindElements() {
+        String[] sorted = Arrays.copyOf(intro, 4);
+        Arrays.sort(sorted);
+        int exact = Arrays.binarySearch(sorted, "time");
+        int caseInsensitive = Arrays.binarySearch(sorted, "TiMe", String::compareToIgnoreCase);
+
+        assertEquals("time", sorted[exact]);
+        assertEquals(2, exact);
+        assertEquals(exact, caseInsensitive);
+    }
+
+    @Test
+    public void whenNullElement_thenArraysHashCodeNotEqual() {
+        int beforeChange = Arrays.hashCode(intro);
+        int before = intro.hashCode();
+        intro[3] = null;
+        int after = intro.hashCode();
+        int afterChange = Arrays.hashCode(intro);
+
+        assertNotEquals(beforeChange, afterChange);
+        assertEquals(before, after);
+    }
+
+    @Test
+    public void whenNestedArrayNullElement_thenEqualsFailDeepHashPass() {
+        Object[] looping = new Object[] { intro, intro };
+        int deepHashBefore = Arrays.deepHashCode(looping);
+        int hashBefore = Arrays.hashCode(looping);
+
+        intro[3] = null;
+
+        int hashAfter = Arrays.hashCode(looping);
+        int deepHashAfter = Arrays.deepHashCode(looping);
+
+        assertEquals(hashAfter, hashBefore);
+        assertNotEquals(deepHashAfter, deepHashBefore);
+    }
+
+    @Test
+    public void whenStreamBadIndex_thenException() {
+        assertEquals(Arrays.stream(intro).count(), 4);
+
+        exception.expect(ArrayIndexOutOfBoundsException.class);
+        Arrays.stream(intro, 2, 1).count();
+    }
+
+    @Test
+    public void whenSetAllToUpper_thenAppliedToAllElements() {
+        String[] longAgo = new String[4];
+        Arrays.setAll(longAgo, i -> intro[i].toUpperCase());
+
+        assertArrayEquals(longAgo, new String[] { "ONCE", "UPON", "A", "TIME" });
+    }
+
+    @Test
+    public void whenToString_thenFormattedArrayString() {
+        assertEquals("[once, upon, a, time]", Arrays.toString(intro));
+    }
+
+    @Test
+    public void whenNestedArrayDeepString_thenFormattedArraysString() {
+        String[] end = { "the", "end" };
+        Object[] story = new Object[] { intro, new String[] { "chapter one", "chapter two" }, end };
+
+        assertEquals("[[once, upon, a, time], [chapter one, chapter two], [the, end]]", Arrays.deepToString(story));
+    }
+
+    @Test
+    public void whenAsList_thenImmutableArray() {
+        List<String> rets = Arrays.asList(intro);
+
+        assertTrue(rets.contains("upon"));
+        assertTrue(rets.contains("time"));
+        assertEquals(rets.size(), 4);
+
+        exception.expect(UnsupportedOperationException.class);
+        rets.add("the");
+    }
+}

core-java/src/test/java/com/baeldung/linkedlist/MiddleElementLookupUnitTest.java

@@ -1,52 +1,97 @@
 package com.baeldung.linkedlist;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+import java.util.LinkedList;
 
 import org.junit.Test;
 
 public class MiddleElementLookupUnitTest {
 
     @Test
-    public void whenFindingMiddle_thenMiddleFound() {
-        String middle = MiddleElementLookup.findMiddleElement(createList(5).head());
-        assertEquals("3", middle);
-
-        middle = MiddleElementLookup.findMiddleElement(createList(4).head());
-        assertEquals("2", middle);
+    public void whenFindingMiddleLinkedList_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementLinkedList(createLinkedList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementLinkedList(createLinkedList(4))
+          .get());
     }
 
     @Test
-    public void whenFindingMiddle1PassRecursively_thenMiddleFound() {
-        String middle = MiddleElementLookup.findMiddleElement1PassRecursively(createList(5).head());
-        assertEquals("3", middle);
-
-        middle = MiddleElementLookup.findMiddleElement1PassRecursively(createList(4).head());
-        assertEquals("2", middle);
+    public void whenFindingMiddleFromHead_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementFromHead(createNodesList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementFromHead(createNodesList(4))
+          .get());
     }
 
     @Test
-    public void whenFindingMiddle1PassIteratively_thenMiddleFound() {
-        String middle = MiddleElementLookup.findMiddleElement1PassIteratively(createList(5).head());
-        assertEquals("3", middle);
-
-        middle = MiddleElementLookup.findMiddleElement1PassIteratively(createList(4).head());
-        assertEquals("2", middle);
+    public void whenFindingMiddleFromHead1PassRecursively_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(createNodesList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(createNodesList(4))
+          .get());
     }
 
     @Test
-    public void whenListEmptyOrNull_thenMiddleNull() {
-        String middle = MiddleElementLookup.findMiddleElement(null);
-        assertEquals(null, middle);
-
-        middle = MiddleElementLookup.findMiddleElement1PassIteratively(null);
-        assertEquals(null, middle);
-
-        middle = MiddleElementLookup.findMiddleElement1PassRecursively(null);
-        assertEquals(null, middle);
+    public void whenFindingMiddleFromHead1PassIteratively_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(createNodesList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(createNodesList(4))
+          .get());
     }
 
-    private static LinkedList createList(int n) {
-        LinkedList list = new LinkedList();
+    @Test
+    public void whenListEmptyOrNull_thenMiddleNotFound() {
+        // null list
+        assertFalse(MiddleElementLookup
+          .findMiddleElementLinkedList(null)
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead(null)
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(null)
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(null)
+          .isPresent());
+
+        // empty LinkedList
+        assertFalse(MiddleElementLookup
+          .findMiddleElementLinkedList(new LinkedList<>())
+          .isPresent());
+
+        // LinkedList with nulls
+        LinkedList<String> nullsList = new LinkedList<>();
+        nullsList.add(null);
+        nullsList.add(null);
+        assertFalse(MiddleElementLookup
+          .findMiddleElementLinkedList(nullsList)
+          .isPresent());
+
+        // nodes with null values
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead(new Node(null))
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(new Node(null))
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(new Node(null))
+          .isPresent());
+    }
+
+    private static LinkedList<String> createLinkedList(int n) {
+        LinkedList<String> list = new LinkedList<>();
 
         for (int i = 1; i <= n; i++) {
             list.add(String.valueOf(i));
@@ -55,4 +100,17 @@ public class MiddleElementLookupUnitTest {
         return list;
     }
 
+    private static Node createNodesList(int n) {
+        Node head = new Node("1");
+        Node current = head;
+
+        for (int i = 2; i <= n; i++) {
+            Node newNode = new Node(String.valueOf(i));
+            current.setNext(newNode);
+            current = newNode;
+        }
+
+        return head;
+    }
+
 }

core-java/src/test/java/com/baeldung/money/JavaMoneyUnitManualTest.java

@@ -179,7 +179,7 @@ public class JavaMoneyUnitManualTest {
         MonetaryAmountFormat customFormat = MonetaryFormats.getAmountFormat(AmountFormatQueryBuilder
           .of(Locale.US)
           .set(CurrencyStyle.NAME)
-          .set("pattern", "00000.00 <EFBFBD>")
+          .set("pattern", "00000.00 US Dollar")
           .build());
         String customFormatted = customFormat.format(oneDollar);
 

core-java/src/test/java/com/baeldung/scripting/NashornUnitTest.java

@@ -104,7 +104,7 @@ public class NashornUnitTest {
     public void loadExamples() throws ScriptException {
         Object loadResult = engine.eval("load('classpath:js/script.js');" + "increment(5)");
 
-        Assert.assertEquals(6.0, loadResult);
+        Assert.assertEquals(6, ((Double) loadResult).intValue());
 
         Object math = engine.eval("var math = loadWithNewGlobal('classpath:js/math_module.js');" + "math.increment(5);");
 

core-kotlin/src/main/kotlin/com/baeldung/enums/CardType.kt

@@ -0,0 +1,23 @@
+package com.baeldung.enums
+
+enum class CardType(val color: String) : ICardLimit {
+    SILVER("gray") {
+        override fun getCreditLimit() = 100000
+        override fun calculateCashbackPercent() = 0.25f
+    },
+    GOLD("yellow") {
+        override fun getCreditLimit() = 200000
+        override fun calculateCashbackPercent(): Float = 0.5f
+    },
+    PLATINUM("black") {
+        override fun getCreditLimit() = 300000
+        override fun calculateCashbackPercent() = 0.75f
+    };
+
+    companion object {
+        fun getCardTypeByColor(color: String) = values().firstOrNull { it.color == color }
+        fun getCardTypeByName(name: String) = valueOf(name.toUpperCase())
+    }
+
+    abstract fun calculateCashbackPercent(): Float
+}

core-kotlin/src/main/kotlin/com/baeldung/enums/ICardLimit.kt

@@ -0,0 +1,5 @@
+package com.baeldung.enums
+
+interface ICardLimit {
+    fun getCreditLimit(): Int
+}

core-kotlin/src/test/kotlin/com/baeldung/enums/CardTypeUnitTest.kt

@@ -0,0 +1,84 @@
+package com.baeldung.enums
+
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+internal class CardTypeUnitTest {
+
+    @Test
+    fun givenSilverCardType_whenCalculateCashbackPercent_thenReturnCashbackValue() {
+        assertEquals(0.25f, CardType.SILVER.calculateCashbackPercent())
+    }
+
+    @Test
+    fun givenGoldCardType_whenCalculateCashbackPercent_thenReturnCashbackValue() {
+        assertEquals(0.5f, CardType.GOLD.calculateCashbackPercent())
+    }
+
+    @Test
+    fun givenPlatinumCardType_whenCalculateCashbackPercent_thenReturnCashbackValue() {
+        assertEquals(0.75f, CardType.PLATINUM.calculateCashbackPercent())
+    }
+
+    @Test
+    fun givenSilverCardType_whenGetCreditLimit_thenReturnCreditLimit() {
+        assertEquals(100000, CardType.SILVER.getCreditLimit())
+    }
+
+    @Test
+    fun givenGoldCardType_whenGetCreditLimit_thenReturnCreditLimit() {
+        assertEquals(200000, CardType.GOLD.getCreditLimit())
+    }
+
+    @Test
+    fun givenPlatinumCardType_whenGetCreditLimit_thenReturnCreditLimit() {
+        assertEquals(300000, CardType.PLATINUM.getCreditLimit())
+    }
+
+    @Test
+    fun givenSilverCardType_whenCheckColor_thenReturnColor() {
+        assertEquals("gray", CardType.SILVER.color)
+    }
+
+    @Test
+    fun givenGoldCardType_whenCheckColor_thenReturnColor() {
+        assertEquals("yellow", CardType.GOLD.color)
+    }
+
+    @Test
+    fun givenPlatinumCardType_whenCheckColor_thenReturnColor() {
+        assertEquals("black", CardType.PLATINUM.color)
+    }
+
+    @Test
+    fun whenGetCardTypeByColor_thenSilverCardType() {
+        Assertions.assertEquals(CardType.SILVER, CardType.getCardTypeByColor("gray"))
+    }
+
+    @Test
+    fun whenGetCardTypeByColor_thenGoldCardType() {
+        Assertions.assertEquals(CardType.GOLD, CardType.getCardTypeByColor("yellow"))
+    }
+
+    @Test
+    fun whenGetCardTypeByColor_thenPlatinumCardType() {
+        Assertions.assertEquals(CardType.PLATINUM, CardType.getCardTypeByColor("black"))
+    }
+
+    @Test
+    fun whenGetCardTypeByName_thenSilverCardType() {
+        Assertions.assertEquals(CardType.SILVER, CardType.getCardTypeByName("silver"))
+    }
+
+    @Test
+    fun whenGetCardTypeByName_thenGoldCardType() {
+        Assertions.assertEquals(CardType.GOLD, CardType.getCardTypeByName("gold"))
+    }
+
+    @Test
+    fun whenGetCardTypeByName_thenPlatinumCardType() {
+        Assertions.assertEquals(CardType.PLATINUM, CardType.getCardTypeByName("platinum"))
+    }
+
+}

couchbase/src/main/java/com/baeldung/couchbase/async/service/ClusterServiceImpl.java

@@ -5,6 +5,7 @@ import java.util.concurrent.ConcurrentHashMap;
 
 import javax.annotation.PostConstruct;
 
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import com.couchbase.client.java.Bucket;
@@ -18,6 +19,11 @@ public class ClusterServiceImpl implements ClusterService {
 
     private Cluster cluster;
     private Map<String, Bucket> buckets = new ConcurrentHashMap<>();
+    
+    @Autowired
+    public ClusterServiceImpl(Cluster cluster) {
+        this.cluster = cluster;
+    }
 
     @PostConstruct
     private void init() {

couchbase/src/main/java/com/baeldung/couchbase/async/service/TutorialBucketService.java

@@ -18,6 +18,7 @@ public class TutorialBucketService extends AbstractBucketService {
     @Autowired
     public TutorialBucketService(ClusterService clusterService) {
         super(clusterService);
+        openBucket();
     }
 
     @Override

couchbase/src/test/java/com/baeldung/couchbase/async/person/PersonCrudServiceIntegrationTestConfig.java

@@ -0,0 +1,24 @@
+package com.baeldung.couchbase.async.person;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+
+import com.couchbase.client.java.Cluster;
+import com.couchbase.client.java.CouchbaseCluster;
+import com.couchbase.client.java.env.CouchbaseEnvironment;
+import com.couchbase.client.java.env.DefaultCouchbaseEnvironment;
+
+@Configuration
+@ComponentScan(basePackages = {"com.baeldung.couchbase.async.service", "com.baeldung.couchbase.n1ql"})
+public class PersonCrudServiceIntegrationTestConfig {
+    
+    @Bean
+    public Cluster cluster() {
+        CouchbaseEnvironment env = DefaultCouchbaseEnvironment.builder()
+          .connectTimeout(60000)
+          .build();
+        return CouchbaseCluster.create(env, "127.0.0.1");
+    }
+
+}

couchbase/src/test/java/com/baeldung/couchbase/async/person/PersonCrudServiceLiveTest.java

@@ -1,27 +1,31 @@
 package com.baeldung.couchbase.async.person;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
 
-import javax.annotation.PostConstruct;
-
 import org.apache.commons.lang3.RandomStringUtils;
+import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
 import com.baeldung.couchbase.async.AsyncIntegrationTest;
-import com.baeldung.couchbase.async.person.Person;
-import com.baeldung.couchbase.async.person.PersonCrudService;
-import com.baeldung.couchbase.async.person.PersonDocumentConverter;
 import com.baeldung.couchbase.async.service.BucketService;
 import com.couchbase.client.java.Bucket;
 import com.couchbase.client.java.document.JsonDocument;
 
-public class PersonCrudServiceIntegrationTest extends AsyncIntegrationTest {
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = {PersonCrudServiceIntegrationTestConfig.class})
+public class PersonCrudServiceLiveTest extends AsyncIntegrationTest {
 
     @Autowired
     private PersonCrudService personService;
@@ -35,8 +39,8 @@ public class PersonCrudServiceIntegrationTest extends AsyncIntegrationTest {
 
     private Bucket bucket;
 
-    @PostConstruct
-    private void init() {
+    @Before
+    public void init() {
         bucket = bucketService.getBucket();
     }
 

couchbase/src/test/java/com/baeldung/couchbase/async/service/ClusterServiceLiveTest.java

@@ -18,7 +18,7 @@ import com.couchbase.client.java.Bucket;
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration(classes = { AsyncIntegrationTestConfig.class })
 @TestExecutionListeners(listeners = { DependencyInjectionTestExecutionListener.class })
-public class ClusterServiceIntegrationTest extends AsyncIntegrationTest {
+public class ClusterServiceLiveTest extends AsyncIntegrationTest {
 
     @Autowired
     private ClusterService couchbaseService;

couchbase/src/test/java/com/baeldung/couchbase/mapreduce/StudentGradeServiceLiveTest.java

@@ -14,8 +14,8 @@ import com.couchbase.client.java.document.JsonDocument;
 import com.couchbase.client.java.view.ViewResult;
 import com.couchbase.client.java.view.ViewRow;
 
-public class StudentGradeServiceIntegrationTest {
-    private static final Logger logger = LoggerFactory.getLogger(StudentGradeServiceIntegrationTest.class);
+public class StudentGradeServiceLiveTest {
+    private static final Logger logger = LoggerFactory.getLogger(StudentGradeServiceLiveTest.class);
             
     static StudentGradeService studentGradeService;
     static Set<String> gradeIds = new HashSet<>();

couchbase/src/test/java/com/baeldung/couchbase/n1ql/N1QLLiveTest.java

@@ -1,5 +1,23 @@
 package com.baeldung.couchbase.n1ql;
 
+import static com.baeldung.couchbase.n1ql.CodeSnippets.extractJsonResult;
+import static com.couchbase.client.java.query.Select.select;
+import static com.couchbase.client.java.query.dsl.Expression.i;
+import static com.couchbase.client.java.query.dsl.Expression.s;
+import static com.couchbase.client.java.query.dsl.Expression.x;
+import static org.junit.Assert.assertNotNull;
+
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
 import com.couchbase.client.java.Bucket;
 import com.couchbase.client.java.Cluster;
 import com.couchbase.client.java.document.JsonDocument;
@@ -10,28 +28,13 @@ import com.couchbase.client.java.query.N1qlQueryResult;
 import com.couchbase.client.java.query.N1qlQueryRow;
 import com.couchbase.client.java.query.Statement;
 import com.fasterxml.jackson.databind.JsonNode;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.test.context.ContextConfiguration;
-import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
 import rx.Observable;
 
-import java.util.List;
-import java.util.UUID;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-import java.util.stream.Stream;
-
-import static com.baeldung.couchbase.n1ql.CodeSnippets.extractJsonResult;
-import static com.couchbase.client.java.query.Select.select;
-import static com.couchbase.client.java.query.dsl.Expression.*;
-import static org.junit.Assert.assertNotNull;
-
 
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration(classes = { IntegrationTestConfig.class })
-public class N1QLIntegrationTest {
+public class N1QLLiveTest {
 
 
     @Autowired

couchbase/src/test/java/com/baeldung/couchbase/spring/person/PersonCrudServiceLiveTest.java

@@ -10,7 +10,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 
 import com.baeldung.couchbase.spring.IntegrationTest;
 
-public class PersonCrudServiceIntegrationTest extends IntegrationTest {
+public class PersonCrudServiceLiveTest extends IntegrationTest {
 
     private static final String CLARK_KENT = "Clark Kent";
     private static final String SMALLVILLE = "Smallville";

couchbase/src/test/java/com/baeldung/couchbase/spring/service/ClusterServiceLiveTest.java

@@ -17,7 +17,7 @@ import com.couchbase.client.java.Bucket;
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration(classes = { IntegrationTestConfig.class })
 @TestExecutionListeners(listeners = { DependencyInjectionTestExecutionListener.class })
-public class ClusterServiceIntegrationTest extends IntegrationTest {
+public class ClusterServiceLiveTest extends IntegrationTest {
 
     @Autowired
     private ClusterService couchbaseService;

custom-pmd/src/main/java/org/baeldung/pmd/UnitTestNamingConventionRule.java

@@ -14,17 +14,16 @@ public class UnitTestNamingConventionRule extends AbstractJavaRule {
       "ManualTest",
       "JdbcTest",
       "LiveTest",
-      "UnitTest");
+      "UnitTest",
+      "jmhTest");
 
     public Object visit(ASTClassOrInterfaceDeclaration node, Object data) {
         String className = node.getImage();
         Objects.requireNonNull(className);
 
-        if (className.endsWith("Test") || className.endsWith("Tests")) {
-            if (allowedEndings.stream()
-              .noneMatch(className::endsWith)) {
-                addViolation(data, node);
-            }
+        if (className.endsWith("Tests")
+                || (className.endsWith("Test") && allowedEndings.stream().noneMatch(className::endsWith))) {
+            addViolation(data, node);
         }
 
         return data;

ejb/ejb-client/pom.xml

@@ -3,7 +3,6 @@
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <artifactId>ejb-client</artifactId>
-    <name>EJB3 Client Maven</name>
     <description>EJB3 Client Maven</description>
 
     <parent>

ethereumj/README.md

@@ -3,3 +3,4 @@
 ### Relevant Articles:
 - [Introduction to EthereumJ](http://www.baeldung.com/ethereumj)
 - [Creating and Deploying Smart Contracts with Solidity](http://www.baeldung.com/smart-contracts-ethereum-solidity)
+- [Lightweight Ethereum Clients Using Web3j](http://www.baeldung.com/web3j)

ethereumj/pom.xml

@@ -10,10 +10,10 @@
     <name>ethereumj</name>
 
     <parent>
-        <artifactId>parent-boot-5</artifactId>
+        <artifactId>parent-boot-1</artifactId>
         <groupId>com.baeldung</groupId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../parent-boot-5</relativePath>
+        <relativePath>../parent-boot-1</relativePath>
     </parent>
 
     <repositories>

flips/pom.xml

@@ -8,10 +8,10 @@
     <name>flips</name>
 
     <parent>
-        <artifactId>parent-boot-5</artifactId>
+        <artifactId>parent-boot-1</artifactId>
         <groupId>com.baeldung</groupId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../parent-boot-5</relativePath>
+        <relativePath>../parent-boot-1</relativePath>
     </parent>
 
     <dependencies>

flips/src/test/java/com/baeldung/flips/controller/FlipControllerIntegrationTest.java

@@ -23,7 +23,7 @@ import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
 }, webEnvironment = SpringBootTest.WebEnvironment.MOCK)
 @AutoConfigureMockMvc
 @ActiveProfiles("dev")
-public class FlipControllerTest {
+public class FlipControllerIntegrationTest {
 
     @Autowired private MockMvc mvc;
 

flyway/pom.xml

@@ -8,10 +8,10 @@
     <description>Flyway Callbacks Demo</description>
 
     <parent>
-        <artifactId>parent-boot-5</artifactId>
+        <artifactId>parent-boot-1</artifactId>
         <groupId>com.baeldung</groupId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../parent-boot-5</relativePath>
+        <relativePath>../parent-boot-1</relativePath>
     </parent>
 
     <dependencies>

grpc/pom.xml

@@ -5,8 +5,6 @@
     <artifactId>grpc-demo</artifactId>
     <version>0.0.1-SNAPSHOT</version>
     <packaging>jar</packaging>
-    <name>grpc-demo</name>
-    <url>http://maven.apache.org</url>
 
     <parent>
         <groupId>com.baeldung</groupId>

gson/README.md

@@ -6,3 +6,4 @@
 ### Relevant Articles: 
 - [Gson Deserialization Cookbook](http://www.baeldung.com/gson-deserialization-guide)
 - [Jackson vs Gson](http://www.baeldung.com/jackson-vs-gson)
+- [Exclude Fields from Serialization in Gson](http://www.baeldung.com/gson-exclude-fields-serialization)

guest/spring-boot-app/WebContent/META-INF/MANIFEST.MF

@@ -1,3 +1,2 @@
 Manifest-Version: 1.0
 Class-Path: 
-

guest/spring-boot-app/docker/Dockerfile

@@ -0,0 +1,16 @@
+# Alpine Linux with OpenJDK JRE
+FROM openjdk:8-jre-alpine
+RUN apk add --no-cache bash
+
+# copy fat WAR
+COPY spring-boot-app-0.0.1-SNAPSHOT.war /app.war
+
+# copy fat WAR
+COPY logback.xml /logback.xml
+
+COPY run.sh /run.sh
+
+# runs application
+#CMD ["/usr/bin/java", "-jar", "-Dspring.profiles.active=default", "-Dlogging.config=/logback.xml", "/app.war"]
+
+ENTRYPOINT ["/run.sh"]

guest/spring-boot-app/docker/logback.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <include resource="org/springframework/boot/logging/logback/base.xml"/>
+    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
+        <file>/var/log/Application/application.log</file>
+        <append>true</append>
+        <encoder>
+            <pattern>%-7d{yyyy-MM-dd HH:mm:ss:SSS} %m%n</pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="FILE" />
+    </root>
+</configuration>

guest/spring-boot-app/docker/run.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+java -Dspring.profiles.active=$1 -Dlogging.config=/logback.xml -jar /app.war
+

guest/spring-boot-app/pom.xml

@@ -51,6 +51,22 @@
                     <warSourceDirectory>WebContent</warSourceDirectory>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>repackage</goal>
+                        </goals>
+                        <configuration>
+                            <mainClass>com.stackify.Application</mainClass>
+                            <outputDirectory>${project.basedir}/docker</outputDirectory>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+
         </plugins>
     </build>
 
@@ -58,4 +74,4 @@
         <tomcat.version>8.0.43</tomcat.version>
     </properties>
 
-</project>
+</project>

guest/spring-mvc/pom.xml

@@ -27,28 +27,6 @@
         </dependency>
     </dependencies>
 
-    <repositories>
-        <repository>
-            <id>spring-milestones</id>
-            <name>Spring Milestones</name>
-            <url>https://repo.spring.io/milestone</url>
-            <snapshots>
-                <enabled>false</enabled>
-            </snapshots>
-        </repository>
-    </repositories>
-
-    <pluginRepositories>
-        <pluginRepository>
-            <id>spring-milestones</id>
-            <name>Spring Milestones</name>
-            <url>https://repo.spring.io/milestone</url>
-            <snapshots>
-                <enabled>false</enabled>
-            </snapshots>
-        </pluginRepository>
-    </pluginRepositories>
-
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

guest/spring-security/pom.xml

@@ -45,28 +45,6 @@
         </dependency>
     </dependencies>
 
-    <repositories>
-        <repository>
-            <id>spring-milestones</id>
-            <name>Spring Milestones</name>
-            <url>https://repo.spring.io/milestone</url>
-            <snapshots>
-                <enabled>false</enabled>
-            </snapshots>
-        </repository>
-    </repositories>
-
-    <pluginRepositories>
-        <pluginRepository>
-            <id>spring-milestones</id>
-            <name>Spring Milestones</name>
-            <url>https://repo.spring.io/milestone</url>
-            <snapshots>
-                <enabled>false</enabled>
-            </snapshots>
-        </pluginRepository>
-    </pluginRepositories>
-
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

hibernate5/src/main/java/com/baeldung/hibernate/HibernateUtil.java

@@ -1,5 +1,7 @@
 package com.baeldung.hibernate;
 
+import com.baeldung.hibernate.optimisticlocking.OptimisticLockingCourse;
+import com.baeldung.hibernate.optimisticlocking.OptimisticLockingStudent;
 import com.baeldung.hibernate.pessimisticlocking.Individual;
 import com.baeldung.hibernate.pessimisticlocking.PessimisticLockingCourse;
 import com.baeldung.hibernate.pessimisticlocking.PessimisticLockingEmployee;
@@ -70,6 +72,8 @@ public class HibernateUtil {
         metadataSources.addAnnotatedClass(PessimisticLockingCourse.class);
         metadataSources.addAnnotatedClass(com.baeldung.hibernate.pessimisticlocking.Customer.class);
         metadataSources.addAnnotatedClass(com.baeldung.hibernate.pessimisticlocking.Address.class);
+        metadataSources.addAnnotatedClass(OptimisticLockingCourse.class);
+        metadataSources.addAnnotatedClass(OptimisticLockingStudent.class);
 
         Metadata metadata = metadataSources.buildMetadata();
         return metadata.getSessionFactoryBuilder()

hibernate5/src/main/java/com/baeldung/hibernate/jpabootstrap/application/Application.java

@@ -0,0 +1,34 @@
+package com.baeldung.hibernate.jpabootstrap.application;
+
+import com.baeldung.hibernate.jpabootstrap.config.JpaEntityManagerFactory;
+import com.baeldung.hibernate.jpabootstrap.entities.User;
+import javax.persistence.EntityManager;
+
+public class Application {
+    
+    public static void main(String[] args) {
+        EntityManager entityManager = getJpaEntityManager();
+        User user = entityManager.find(User.class, 1);
+        System.out.println(user);
+        entityManager.getTransaction().begin();
+        user.setName("John");
+        user.setEmail("john@domain.com");
+        entityManager.merge(user);
+        entityManager.getTransaction().commit();
+        entityManager.getTransaction().begin();
+        entityManager.persist(new User("Monica", "monica@domain.com"));
+        entityManager.getTransaction().commit();
+ 
+         // additional CRUD operations
+         
+    }
+
+    private static class EntityManagerHolder {
+        private static final EntityManager ENTITY_MANAGER = new JpaEntityManagerFactory(
+          new Class[]{User.class}).getEntityManager();
+    }
+    
+    public static EntityManager getJpaEntityManager() {
+        return EntityManagerHolder.ENTITY_MANAGER;
+    }
+}

hibernate5/src/main/java/com/baeldung/hibernate/jpabootstrap/config/HibernatePersistenceUnitInfo.java

@@ -0,0 +1,131 @@
+package com.baeldung.hibernate.jpabootstrap.config;
+
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Properties;
+import javax.sql.DataSource;
+import javax.persistence.SharedCacheMode;
+import javax.persistence.ValidationMode;
+import javax.persistence.spi.ClassTransformer;
+import javax.persistence.spi.PersistenceUnitInfo;
+import javax.persistence.spi.PersistenceUnitTransactionType;
+import org.hibernate.jpa.HibernatePersistenceProvider;
+
+public class HibernatePersistenceUnitInfo implements PersistenceUnitInfo {
+    
+    public static final String JPA_VERSION = "2.1";
+    private final String persistenceUnitName;
+    private PersistenceUnitTransactionType transactionType = PersistenceUnitTransactionType.RESOURCE_LOCAL;
+    private final List<String> managedClassNames;
+    private final List<String> mappingFileNames = new ArrayList<>();
+    private final Properties properties;
+    private DataSource jtaDataSource;
+    private DataSource nonjtaDataSource;
+    private final List<ClassTransformer> transformers = new ArrayList<>();
+    
+    public HibernatePersistenceUnitInfo(String persistenceUnitName, List<String> managedClassNames, Properties properties) {
+        this.persistenceUnitName = persistenceUnitName;
+        this.managedClassNames = managedClassNames;
+        this.properties = properties;
+    }
+    
+    @Override
+    public String getPersistenceUnitName() {
+        return persistenceUnitName;
+    }
+ 
+    @Override
+    public String getPersistenceProviderClassName() {
+        return HibernatePersistenceProvider.class.getName();
+    }
+ 
+    @Override
+    public PersistenceUnitTransactionType getTransactionType() {
+        return transactionType;
+    }
+ 
+    public HibernatePersistenceUnitInfo  setJtaDataSource(DataSource jtaDataSource) {
+        this.jtaDataSource = jtaDataSource;
+        this.nonjtaDataSource = null;
+        transactionType = PersistenceUnitTransactionType.JTA;
+        return this;
+    }
+ 
+    @Override
+    public DataSource getJtaDataSource() {
+        return jtaDataSource;
+    }
+    
+    public HibernatePersistenceUnitInfo setNonJtaDataSource(DataSource nonJtaDataSource) {
+        this.nonjtaDataSource = nonJtaDataSource;
+        this.jtaDataSource = null;
+        transactionType = PersistenceUnitTransactionType.RESOURCE_LOCAL;
+        return this;
+    }
+     
+    @Override
+    public DataSource getNonJtaDataSource() {
+        return nonjtaDataSource;
+    }
+ 
+    @Override
+    public List<String> getMappingFileNames() {
+        return mappingFileNames;
+    }
+ 
+    @Override
+    public List<URL> getJarFileUrls() {
+        return Collections.emptyList();
+    }
+ 
+    @Override
+    public URL getPersistenceUnitRootUrl() {
+        return null;
+    }
+ 
+    @Override
+    public List<String> getManagedClassNames() {
+        return managedClassNames;
+    }
+ 
+    @Override
+    public boolean excludeUnlistedClasses() {
+        return false;
+    }
+ 
+    @Override
+    public SharedCacheMode getSharedCacheMode() {
+        return SharedCacheMode.UNSPECIFIED;
+    }
+ 
+    @Override
+    public ValidationMode getValidationMode() {
+        return ValidationMode.AUTO;
+    }
+ 
+    public Properties getProperties() {
+        return properties;
+    }
+ 
+    @Override
+    public String getPersistenceXMLSchemaVersion() {
+        return JPA_VERSION;
+    }
+ 
+    @Override
+    public ClassLoader getClassLoader() {
+        return Thread.currentThread().getContextClassLoader();
+    }
+ 
+    @Override
+    public void addTransformer(ClassTransformer transformer) {
+        transformers.add(transformer);
+    }
+    
+    @Override
+    public ClassLoader getNewTempClassLoader() {
+        return null;
+    }
+}

hibernate5/src/main/java/com/baeldung/hibernate/jpabootstrap/config/JpaEntityManagerFactory.java

@@ -0,0 +1,69 @@
+package com.baeldung.hibernate.jpabootstrap.config;
+
+import com.mysql.cj.jdbc.MysqlDataSource;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.stream.Collectors;
+import javax.persistence.EntityManager;
+import javax.sql.DataSource;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.spi.PersistenceUnitInfo;
+import org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl;
+import org.hibernate.jpa.boot.internal.PersistenceUnitInfoDescriptor;
+
+public class JpaEntityManagerFactory {
+    
+    private final String DB_URL = "jdbc:mysql://databaseurl";
+    private final String DB_USER_NAME = "username";
+    private final String DB_PASSWORD = "password";
+    private final Class[] entityClasses;
+    
+    public JpaEntityManagerFactory(Class[] entityClasses) {
+        this.entityClasses = entityClasses;
+    }
+            
+    public EntityManager getEntityManager() {
+        return getEntityManagerFactory().createEntityManager();
+    }
+    
+    protected EntityManagerFactory getEntityManagerFactory() {
+        PersistenceUnitInfo persistenceUnitInfo = getPersistenceUnitInfo(getClass().getSimpleName());
+        Map<String, Object> configuration = new HashMap<>();
+        return new EntityManagerFactoryBuilderImpl(new PersistenceUnitInfoDescriptor(persistenceUnitInfo), configuration)
+          .build();
+    }
+    
+    protected HibernatePersistenceUnitInfo getPersistenceUnitInfo(String name) {
+        return new HibernatePersistenceUnitInfo(name, getEntityClassNames(), getProperties());
+    }
+    
+    protected List<String> getEntityClassNames() {
+        return Arrays.asList(getEntities())
+          .stream()
+          .map(Class::getName)
+          .collect(Collectors.toList());
+    }
+    
+    protected Properties getProperties() {
+        Properties properties = new Properties();
+        properties.put("hibernate.dialect", "org.hibernate.dialect.MySQLDialect");
+        properties.put("hibernate.id.new_generator_mappings", false);
+        properties.put("hibernate.connection.datasource", getMysqlDataSource());
+        return properties;
+    }
+    
+    protected Class[] getEntities() {
+        return entityClasses;
+    }
+    
+    protected DataSource getMysqlDataSource() {
+	MysqlDataSource mysqlDataSource = new MysqlDataSource();
+        mysqlDataSource.setURL(DB_URL);
+	mysqlDataSource.setUser(DB_USER_NAME);
+        mysqlDataSource.setPassword(DB_PASSWORD);
+	return mysqlDataSource;
+    }
+}

hibernate5/src/main/java/com/baeldung/hibernate/jpabootstrap/entities/User.java

@@ -0,0 +1,45 @@
+package com.baeldung.hibernate.jpabootstrap.entities;
+
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+@Entity
+@Table(name = "users")
+public class User {
+    
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private long id;
+    private String name;
+    private String email;
+    
+    public User(){}
+    
+    public User(String name, String email) {
+        this.name = name;
+        this.email = email;
+    }
+    
+    public void setName(String name) {
+        this.name = name;
+    }
+    
+    public void setEmail(String email) {
+        this.email = email;
+    }
+    
+    public long getId() {
+        return id;
+    }
+    
+    public String getName() {
+        return name;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+}

hibernate5/src/main/java/com/baeldung/hibernate/optimisticlocking/OptimisticLockingCourse.java

@@ -0,0 +1,48 @@
+package com.baeldung.hibernate.optimisticlocking;
+
+import javax.persistence.*;
+
+@Entity
+public class OptimisticLockingCourse {
+
+    @Id
+    private Long id;
+
+    private String name;
+
+    @ManyToOne
+    @JoinTable(name = "optimistic_student_course")
+    private OptimisticLockingStudent student;
+
+    public OptimisticLockingCourse(Long id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+
+    public OptimisticLockingCourse() {
+    }
+
+    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;
+    }
+
+    public OptimisticLockingStudent getStudent() {
+        return student;
+    }
+
+    public void setStudent(OptimisticLockingStudent student) {
+        this.student = student;
+    }
+}

hibernate5/src/main/java/com/baeldung/hibernate/optimisticlocking/OptimisticLockingStudent.java

@@ -0,0 +1,70 @@
+package com.baeldung.hibernate.optimisticlocking;
+
+import javax.persistence.*;
+import java.util.List;
+
+@Entity
+public class OptimisticLockingStudent {
+
+    @Id
+    private Long id;
+
+    private String name;
+
+    private String lastName;
+    @Version
+    private Integer version;
+
+    @OneToMany(mappedBy = "student")
+    private List<OptimisticLockingCourse> courses;
+
+    public OptimisticLockingStudent(Long id, String name, String lastName, List<OptimisticLockingCourse> courses) {
+        this.id = id;
+        this.name = name;
+        this.lastName = lastName;
+        this.courses = courses;
+    }
+
+    public OptimisticLockingStudent() {
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Integer getVersion() {
+        return version;
+    }
+
+    public void setVersion(Integer version) {
+        this.version = version;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+
+    public List<OptimisticLockingCourse> getCourses() {
+        return courses;
+    }
+
+    public void setCourses(List<OptimisticLockingCourse> courses) {
+        this.courses = courses;
+    }
+}

hibernate5/src/test/java/com/baeldung/hibernate/optimisticlocking/OptimisticLockingIntegrationTest.java

@@ -0,0 +1,134 @@
+package com.baeldung.hibernate.optimisticlocking;
+
+import com.baeldung.hibernate.HibernateUtil;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import javax.persistence.EntityManager;
+import javax.persistence.LockModeType;
+import javax.persistence.OptimisticLockException;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class OptimisticLockingIntegrationTest {
+
+    @Before
+    public void setUp() throws IOException {
+        EntityManager entityManager = getEntityManagerWithOpenTransaction();
+        OptimisticLockingCourse course = new OptimisticLockingCourse(1L, "MATH");
+        OptimisticLockingStudent student = new OptimisticLockingStudent(1L, "John", "Doe", Arrays.asList(course));
+        course.setStudent(student);
+        entityManager.persist(course);
+        entityManager.persist(student);
+        entityManager.getTransaction()
+            .commit();
+        entityManager.close();
+    }
+
+    @After
+    public void clean() throws IOException {
+        EntityManager entityManager = getEntityManagerWithOpenTransaction();
+        OptimisticLockingCourse course = entityManager.find(OptimisticLockingCourse.class, 1L);
+        OptimisticLockingStudent student = entityManager.find(OptimisticLockingStudent.class, 1L);
+        entityManager.remove(course);
+        entityManager.remove(student);
+        entityManager.getTransaction()
+            .commit();
+        entityManager.close();
+    }
+
+    @Test(expected = OptimisticLockException.class)
+    public void givenVersionedEntities_whenConcurrentUpdate_thenOptimisticLockException() throws IOException {
+        EntityManager em = getEntityManagerWithOpenTransaction();
+        OptimisticLockingStudent student = em.find(OptimisticLockingStudent.class, 1L);
+
+        EntityManager em2 = getEntityManagerWithOpenTransaction();
+        OptimisticLockingStudent student2 = em2.find(OptimisticLockingStudent.class, 1L);
+        student2.setName("RICHARD");
+        em2.persist(student2);
+        em2.getTransaction()
+            .commit();
+        em2.close();
+
+        student.setName("JOHN");
+        em.persist(student);
+        em.getTransaction()
+            .commit();
+        em.close();
+    }
+
+    @Test(expected = OptimisticLockException.class)
+    public void givenVersionedEntitiesWithLockByFindMethod_whenConcurrentUpdate_thenOptimisticLockException() throws IOException {
+        EntityManager em = getEntityManagerWithOpenTransaction();
+        OptimisticLockingStudent student = em.find(OptimisticLockingStudent.class, 1L, LockModeType.OPTIMISTIC);
+
+        EntityManager em2 = getEntityManagerWithOpenTransaction();
+        OptimisticLockingStudent student2 = em2.find(OptimisticLockingStudent.class, 1L, LockModeType.OPTIMISTIC_FORCE_INCREMENT);
+        student2.setName("RICHARD");
+        em2.persist(student2);
+        em2.getTransaction()
+            .commit();
+        em2.close();
+
+        student.setName("JOHN");
+        em.persist(student);
+        em.getTransaction()
+            .commit();
+        em.close();
+    }
+
+    @Test(expected = OptimisticLockException.class)
+    public void givenVersionedEntitiesWithLockByRefreshMethod_whenConcurrentUpdate_thenOptimisticLockException() throws IOException {
+        EntityManager em = getEntityManagerWithOpenTransaction();
+        OptimisticLockingStudent student = em.find(OptimisticLockingStudent.class, 1L);
+        em.refresh(student, LockModeType.OPTIMISTIC);
+
+        EntityManager em2 = getEntityManagerWithOpenTransaction();
+        OptimisticLockingStudent student2 = em2.find(OptimisticLockingStudent.class, 1L);
+        em.refresh(student, LockModeType.OPTIMISTIC_FORCE_INCREMENT);
+        student2.setName("RICHARD");
+        em2.persist(student2);
+        em2.getTransaction()
+            .commit();
+        em2.close();
+
+        student.setName("JOHN");
+        em.persist(student);
+        em.getTransaction()
+            .commit();
+        em.close();
+    }
+
+    @Test(expected = OptimisticLockException.class)
+    public void givenVersionedEntitiesWithLockByLockMethod_whenConcurrentUpdate_thenOptimisticLockException() throws IOException {
+        EntityManager em = getEntityManagerWithOpenTransaction();
+        OptimisticLockingStudent student = em.find(OptimisticLockingStudent.class, 1L);
+        em.lock(student, LockModeType.OPTIMISTIC);
+
+        EntityManager em2 = getEntityManagerWithOpenTransaction();
+        OptimisticLockingStudent student2 = em2.find(OptimisticLockingStudent.class, 1L);
+        em.lock(student, LockModeType.OPTIMISTIC_FORCE_INCREMENT);
+        student2.setName("RICHARD");
+        em2.persist(student2);
+        em2.getTransaction()
+            .commit();
+        em2.close();
+
+        student.setName("JOHN");
+        em.persist(student);
+        em.getTransaction()
+            .commit();
+        em.close();
+    }
+
+    protected static EntityManager getEntityManagerWithOpenTransaction() throws IOException {
+        String propertyFileName = "hibernate-pessimistic-locking.properties";
+        EntityManager entityManager = HibernateUtil.getSessionFactory(propertyFileName)
+            .openSession();
+        entityManager.getTransaction()
+            .begin();
+
+        return entityManager;
+    }
+}

hystrix/pom.xml

@@ -6,10 +6,10 @@
     <name>hystrix</name>
 
     <parent>
-        <artifactId>parent-boot-5</artifactId>
+        <artifactId>parent-boot-1</artifactId>
         <groupId>com.baeldung</groupId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../parent-boot-5</relativePath>
+        <relativePath>../parent-boot-1</relativePath>
     </parent>
 
     <dependencies>

java-websocket/pom.xml

@@ -5,8 +5,6 @@
     <artifactId>java-websocket</artifactId>
     <packaging>war</packaging>
     <version>0.0.1-SNAPSHOT</version>
-    <name>java-websocket Maven Webapp</name>
-    <url>http://maven.apache.org</url>
 
     <parent>
         <groupId>com.baeldung</groupId>

javax-servlets/README.md

@@ -3,3 +3,5 @@
 - [An MVC Example with Servlets and JSP](http://www.baeldung.com/mvc-servlet-jsp)
 - [Handling Cookies and a Session in a Java Servlet](http://www.baeldung.com/java-servlet-cookies-session)
 - [Uploading Files with Servlets and JSP](http://www.baeldung.com/upload-file-servlet)
+- [Example of Downloading File in a Servlet](http://www.baeldung.com/servlet-download-file)
+- [Returning a JSON Response from a Servlet](http://www.baeldung.com/servlet-json-response)

javax-servlets/src/main/java/com/baeldung/model/Employee.java

@@ -5,9 +5,9 @@ public class Employee {
 	private int id;
     private String name;
     private String department;
-    private Double salary;
+    private long salary;
 	
-    public Employee(int id, String name, String department, Double salary) {
+    public Employee(int id, String name, String department, long salary) {
 		super();
 		this.id = id;
 		this.name = name;
@@ -61,11 +61,11 @@ public class Employee {
 		this.department = department;
 	}
 	
-    public Double getSalary() {
+    public long getSalary() {
 		return salary;
 	}
 	
-    public void setSalary(Double salary) {
+    public void setSalary(long salary) {
 		this.salary = salary;
 	}
 	

javax-servlets/src/main/java/com/baeldung/servlets/EmployeeServlet.java

@@ -14,18 +14,15 @@ import com.google.gson.Gson;
 
 @WebServlet(name = "EmployeeServlet", urlPatterns = "/employeeServlet")
 public class EmployeeServlet extends HttpServlet {
+	
+	private Gson gson = new Gson();
 
 	@Override
-	protected void doPost(HttpServletRequest request, HttpServletResponse response)
+	public void doGet(HttpServletRequest request, HttpServletResponse response)
 		throws IOException {
 
-		int id = Integer.parseInt(request.getParameter("id"));
-		String name = request.getParameter("name");
-		String department = request.getParameter("department");
-		Double salary = Double.parseDouble(request.getParameter("salary"));
-
-		Employee employee = new Employee(id, name, department, salary);
-		String employeeJsonString = new Gson().toJson(employee);
+		Employee employee = new Employee(1, "Karan", "IT", 5000);
+		String employeeJsonString = this.gson.toJson(employee);
 
 		PrintWriter out = response.getWriter();
 		response.setContentType("application/json");

javax-servlets/src/test/java/com/baeldung/servlets/EmployeeServletIntegrationTest.java

@@ -36,21 +36,15 @@ public class EmployeeServletIntegrationTest {
 		int id = 1;
 		String name = "Karan Khanna";
 		String department = "IT";
-		Double salary = 5000.0;
+		long salary = 5000;
 		employee = new Employee(id, name, department, salary);
 
-		//when
-		when(httpServletRequest.getParameter("id")).thenReturn(String.valueOf(id));
-		when(httpServletRequest.getParameter("name")).thenReturn(name);
-		when(httpServletRequest.getParameter("department")).thenReturn(department);
-		when(httpServletRequest.getParameter("salary")).thenReturn(String.valueOf(salary));
-
 		StringWriter sw = new StringWriter();
 		PrintWriter pw = new PrintWriter(sw);
 		when(httpServletResponse.getWriter()).thenReturn(pw);
 
 		EmployeeServlet employeeServlet = new EmployeeServlet();
-		employeeServlet.doPost(httpServletRequest, httpServletResponse);
+		employeeServlet.doGet(httpServletRequest, httpServletResponse);
 
 		String employeeJsonString = sw.getBuffer().toString().trim();
 		Employee fetchedEmployee = new Gson().fromJson(employeeJsonString, Employee.class);

jaxb/pom.xml

@@ -39,6 +39,11 @@
             <artifactId>commons-lang3</artifactId>
             <version>${commons-lang3.version}</version>
         </dependency>
+        <dependency>
+            <groupId>javax.activation</groupId>
+            <artifactId>activation</artifactId>
+            <version>1.1</version>
+        </dependency>
     </dependencies>
 
     <build>

jaxb/src/main/resources/log4jstructuraldp.properties

@@ -0,0 +1,9 @@
+
+# Root logger 
+log4j.rootLogger=INFO, file, stdout
+
+# Write to console
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.Target=System.out
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

jaxb/src/test/java/com/baeldung/jaxb/test/JaxbIntegrationTest.java

@@ -44,7 +44,7 @@ public class JaxbIntegrationTest {
         File bookFile = new File(this.getClass().getResource("/book.xml").getFile());
         String sampleBookXML = FileUtils.readFileToString(sampleBookFile, "UTF-8");
         String marshallerBookXML = FileUtils.readFileToString(bookFile, "UTF-8");
-        Assert.assertEquals(sampleBookXML, marshallerBookXML);
+        Assert.assertEquals(sampleBookXML.replace("\r", "").replace("\n", ""), marshallerBookXML.replace("\r", "").replace("\n", ""));
     }
 
     @Test

jaxb/src/test/resources/book.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<book id="1">
+    <title>Book1</title>
+    <date>2016-12-16T17:28:49.718Z</date>
+</book>

jee-7/src/test/java/com/baeldung/convListVal/ConvListValLiveTest.java

@@ -22,7 +22,7 @@ import org.openqa.selenium.WebElement;
 import org.openqa.selenium.support.FindBy;
 
 @RunWith(Arquillian.class)
-public class ConvListValIntegrationTest {
+public class ConvListValLiveTest {
 
     @ArquillianResource
     private URL deploymentUrl;

jee-7/src/test/java/com/baeldung/timer/AutomaticTimerBeanLiveTest.java

@@ -21,7 +21,7 @@ import static org.hamcrest.Matchers.equalTo;
 
 
 @RunWith(Arquillian.class)
-public class AutomaticTimerBeanIntegrationTest {
+public class AutomaticTimerBeanLiveTest {
 
     //the @AutomaticTimerBean has a method called every 10 seconds
     //testing the difference ==> 100000

jee-7/src/test/java/com/baeldung/timer/ProgrammaticAtFixedRateTimerBeanLiveTest.java

@@ -21,7 +21,7 @@ import static org.hamcrest.Matchers.is;
 
 
 @RunWith(Arquillian.class)
-public class ProgrammaticAtFixedRateTimerBeanIntegrationTest {
+public class ProgrammaticAtFixedRateTimerBeanLiveTest {
 
     final static long TIMEOUT = 1000;
     final static long TOLERANCE = 500l;

jee-7/src/test/java/com/baeldung/timer/ProgrammaticTimerBeanLiveTest.java

@@ -19,7 +19,7 @@ import static org.hamcrest.Matchers.is;
 
 
 @RunWith(Arquillian.class)
-public class ProgrammaticTimerBeanIntegrationTest {
+public class ProgrammaticTimerBeanLiveTest {
 
     final static long TIMEOUT = 5000l;
     final static long TOLERANCE = 1000l;

jee-7/src/test/java/com/baeldung/timer/ProgrammaticWithFixedDelayTimerBeanLiveTest.java

@@ -21,7 +21,7 @@ import static org.hamcrest.Matchers.is;
 
 
 @RunWith(Arquillian.class)
-public class ProgrammaticWithFixedDelayTimerBeanIntegrationTest {
+public class ProgrammaticWithFixedDelayTimerBeanLiveTest {
 
     final static long TIMEOUT = 15000l;
     final static long TOLERANCE = 1000l;

jee-7/src/test/java/com/baeldung/timer/ScheduleTimerBeanLiveTest.java

@@ -20,7 +20,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.equalTo;
 
 @RunWith(Arquillian.class)
-public class ScheduleTimerBeanIntegrationTest {
+public class ScheduleTimerBeanLiveTest {
 
     private final static long TIMEOUT = 5000l;
     private final static long TOLERANCE = 1000l;

jhipster/jhipster-microservice/car-app/pom.xml

@@ -3,10 +3,10 @@
     <modelVersion>4.0.0</modelVersion>
 
     <parent>
-        <artifactId>parent-boot-5</artifactId>
+        <artifactId>parent-boot-1</artifactId>
         <groupId>com.baeldung</groupId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../../parent-boot-5</relativePath>
+        <relativePath>../../../parent-boot-1</relativePath>
     </parent>
 
     <groupId>com.car.app</groupId>

jhipster/jhipster-microservice/dealer-app/pom.xml

@@ -3,10 +3,10 @@
     <modelVersion>4.0.0</modelVersion>
 
     <parent>
-        <artifactId>parent-boot-5</artifactId>
+        <artifactId>parent-boot-1</artifactId>
         <groupId>com.baeldung</groupId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../../parent-boot-5</relativePath>
+        <relativePath>../../../parent-boot-1</relativePath>
     </parent>
 
     <groupId>com.dealer.app</groupId>

jhipster/jhipster-microservice/gateway-app/pom.xml

@@ -3,10 +3,10 @@
     <modelVersion>4.0.0</modelVersion>
 
     <parent>
-        <artifactId>parent-boot-5</artifactId>
+        <artifactId>parent-boot-1</artifactId>
         <groupId>com.baeldung</groupId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../../parent-boot-5</relativePath>
+        <relativePath>../../../parent-boot-1</relativePath>
     </parent>
 
     <groupId>com.gateway</groupId>

jhipster/jhipster-monolithic/pom.xml

@@ -3,10 +3,10 @@
     <modelVersion>4.0.0</modelVersion>
 
     <parent>
-        <artifactId>parent-boot-5</artifactId>
+        <artifactId>parent-boot-1</artifactId>
         <groupId>com.baeldung</groupId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-boot-5</relativePath>
+        <relativePath>../../parent-boot-1</relativePath>
     </parent>
 
     <groupId>com.baeldung</groupId>

jjwt/pom.xml

@@ -10,10 +10,10 @@
     <description>Exercising the JJWT</description>
 
     <parent>
-        <artifactId>parent-boot-5</artifactId>
+        <artifactId>parent-boot-1</artifactId>
         <groupId>com.baeldung</groupId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../parent-boot-5</relativePath>
+        <relativePath>../parent-boot-1</relativePath>
     </parent>
 
     <dependencies>

jmeter/pom.xml

@@ -9,10 +9,10 @@
     <description>Intro to Performance testing using JMeter</description>
 
     <parent>
-        <artifactId>parent-boot-5</artifactId>
+        <artifactId>parent-boot-1</artifactId>
         <groupId>com.baeldung</groupId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../parent-boot-5</relativePath>
+        <relativePath>../parent-boot-1</relativePath>
     </parent>
 
     <dependencies>

jpa-storedprocedure/src/test/java/com/baeldung/jpa/storedprocedure/StoredProcedureLiveTest.java

@@ -15,7 +15,7 @@ import org.junit.Test;
 
 import com.baeldung.jpa.model.Car;
 
-public class StoredProcedureIntegrationTest {
+public class StoredProcedureLiveTest {
 
     private static EntityManagerFactory factory = null;
     private static EntityManager entityManager = null;

kotlin-js/README.md

@@ -0,0 +1,3 @@
+### Relevant Articles: 
+
+- [Kotlin and Javascript](http://www.baeldung.com/kotlin-javascript)

libraries-data/src/test/java/com/baeldung/jcache/EntryProcessorIntegrationTest.java

@@ -15,12 +15,13 @@ import static org.junit.Assert.assertEquals;
 public class EntryProcessorIntegrationTest {
 
     private static final String CACHE_NAME = "MyCache";
+    private static final String CACHE_PROVIDER_NAME = "com.hazelcast.cache.HazelcastCachingProvider";
 
     private Cache<String, String> cache;
 
     @Before
     public void instantiateCache() {
-        CachingProvider cachingProvider = Caching.getCachingProvider();
+        CachingProvider cachingProvider = Caching.getCachingProvider(CACHE_PROVIDER_NAME);
         CacheManager cacheManager = cachingProvider.getCacheManager();
         MutableConfiguration<String, String> config = new MutableConfiguration<>();
         this.cache = cacheManager.createCache(CACHE_NAME, config);
@@ -29,7 +30,7 @@ public class EntryProcessorIntegrationTest {
 
     @After
     public void tearDown() {
-        Caching.getCachingProvider().getCacheManager().destroyCache(CACHE_NAME);
+        Caching.getCachingProvider(CACHE_PROVIDER_NAME).getCacheManager().destroyCache(CACHE_NAME);
     }
 
     @Test

libraries-data/src/test/java/com/baeldung/jcache/EventListenerIntegrationTest.java

@@ -17,6 +17,7 @@ import static org.junit.Assert.assertEquals;
 public class EventListenerIntegrationTest {
 
     private static final String CACHE_NAME = "MyCache";
+    private static final String CACHE_PROVIDER_NAME = "com.hazelcast.cache.HazelcastCachingProvider";
 
     private Cache<String, String> cache;
     private SimpleCacheEntryListener listener;
@@ -24,7 +25,7 @@ public class EventListenerIntegrationTest {
 
     @Before
     public void setup() {
-        CachingProvider cachingProvider = Caching.getCachingProvider();
+        CachingProvider cachingProvider = Caching.getCachingProvider(CACHE_PROVIDER_NAME);
         CacheManager cacheManager = cachingProvider.getCacheManager();
         MutableConfiguration<String, String> config = new MutableConfiguration<String, String>();
         this.cache = cacheManager.createCache("MyCache", config);
@@ -33,7 +34,7 @@ public class EventListenerIntegrationTest {
 
     @After
     public void tearDown() {
-        Caching.getCachingProvider().getCacheManager().destroyCache(CACHE_NAME);
+        Caching.getCachingProvider(CACHE_PROVIDER_NAME).getCacheManager().destroyCache(CACHE_NAME);
     }
 
     @Test

libraries-data/src/test/java/com/baeldung/jcache/JCacheIntegrationTest.java

@@ -14,7 +14,7 @@ public class JCacheIntegrationTest {
 
     @Test
     public void instantiateCache() {
-        CachingProvider cachingProvider = Caching.getCachingProvider();
+        CachingProvider cachingProvider = Caching.getCachingProvider("com.hazelcast.cache.HazelcastCachingProvider");
         CacheManager cacheManager = cachingProvider.getCacheManager();
         MutableConfiguration<String, String> config = new MutableConfiguration<>();
         Cache<String, String> cache = cacheManager.createCache("simpleCache", config);

libraries-data/src/test/resources/reladomo/ReladomoTestConfig.xml

@@ -2,6 +2,6 @@
     <ConnectionManager className="com.gs.fw.common.mithra.test.ConnectionManagerForTests">
         <Property name="resourceName" value="testDb"/>
         <MithraObjectConfiguration className="com.baeldung.reladomo.Department" cacheType="partial"/>
-        <MithraObjectConfiguration className="com.baeldung.reladomo.Employee " cacheType="partial"/>
+        <MithraObjectConfiguration className="com.baeldung.reladomo.Employee" cacheType="partial"/>
     </ConnectionManager>
  </MithraRuntime>

libraries/pom.xml

@@ -709,6 +709,20 @@
             <artifactId>xchart</artifactId>
             <version>${xchart-version}</version>
         </dependency>
+
+        <dependency>
+            <groupId>commons-net</groupId>
+            <artifactId>commons-net</artifactId>
+            <version>${commons-net.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.mockftpserver</groupId>
+            <artifactId>MockFtpServer</artifactId>
+            <version>${mockftpserver.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+
     </dependencies>
 
     <repositories>
@@ -923,6 +937,8 @@
         <typesafe-akka.version>2.5.11</typesafe-akka.version>
         <common-math3-version>3.6.1</common-math3-version>
         <xchart-version>3.5.2</xchart-version>
+        <commons-net.version>3.6</commons-net.version>
+        <mockftpserver.version>2.7.1</mockftpserver.version>
     </properties>
 
 </project>

libraries/src/main/java/com/baeldung/commons/math3/Histogram.java

@@ -10,8 +10,13 @@ import java.util.*;
 
 public class Histogram {
 
+    private Map distributionMap;
+    private int classWidth;
+
     public Histogram() {
 
+        distributionMap = new TreeMap();
+        classWidth = 10;
         Map distributionMap = processRawData();
         List yData = new ArrayList();
         yData.addAll(distributionMap.values());
@@ -42,47 +47,49 @@ public class Histogram {
 
     private Map processRawData() {
 
-        List<Integer> datasetList = Arrays.asList(36, 25, 38, 46, 55, 68, 72, 55, 36, 38, 67, 45, 22, 48, 91, 46, 52, 61, 58, 55);
+        List<Integer> datasetList = Arrays.asList(
+          36, 25, 38, 46, 55, 68, 72,
+          55, 36, 38, 67, 45, 22, 48,
+          91, 46, 52, 61, 58, 55);
         Frequency frequency = new Frequency();
         datasetList.forEach(d -> frequency.addValue(Double.parseDouble(d.toString())));
 
-        int classWidth = 10;
+        datasetList.stream()
+          .map(d -> Double.parseDouble(d.toString()))
+          .distinct()
+          .forEach(observation -> {
+             long observationFrequency = frequency.getCount(observation);
+             int upperBoundary = (observation > classWidth)
+               ? Math.multiplyExact( (int) Math.ceil(observation / classWidth), classWidth)
+               : classWidth;
+             int lowerBoundary = (upperBoundary > classWidth)
+               ? Math.subtractExact(upperBoundary, classWidth)
+               : 0;
+             String bin = lowerBoundary + "-" + upperBoundary;
 
-        Map distributionMap = new TreeMap();
-        List processed = new ArrayList();
-        datasetList.forEach(d -> {
+             updateDistributionMap(lowerBoundary, bin, observationFrequency);
 
-            double observation = Double.parseDouble(d.toString());
-
-            if(processed.contains(observation))
-                return;
-
-            long observationFrequency = frequency.getCount(observation);
-            int upperBoundary = (observation > classWidth) ? Math.multiplyExact( (int) Math.ceil(observation / classWidth), classWidth) : classWidth;
-            int lowerBoundary = (upperBoundary > classWidth) ? Math.subtractExact(upperBoundary, classWidth) : 0;
-            String bin = lowerBoundary + "-" + upperBoundary;
-
-            int prevUpperBoundary = lowerBoundary;
-            int prevLowerBoundary = (lowerBoundary > classWidth) ? lowerBoundary - classWidth : 0;
-            String prevBin = prevLowerBoundary + "-" + prevUpperBoundary;
-            if(!distributionMap.containsKey(prevBin))
-                distributionMap.put(prevBin, 0);
-
-            if(!distributionMap.containsKey(bin)) {
-                distributionMap.put(bin, observationFrequency);
-            }
-            else {
-                long oldFrequency = Long.parseLong(distributionMap.get(bin).toString());
-                distributionMap.replace(bin, oldFrequency + observationFrequency);
-            }
-
-            processed.add(observation);
-
-        });
+          });
 
         return distributionMap;
     }
 
+    private void updateDistributionMap(int lowerBoundary, String bin, long observationFrequency) {
+
+        int prevLowerBoundary = (lowerBoundary > classWidth) ? lowerBoundary - classWidth : 0;
+        String prevBin = prevLowerBoundary + "-" + lowerBoundary;
+        if(!distributionMap.containsKey(prevBin))
+            distributionMap.put(prevBin, 0);
+
+        if(!distributionMap.containsKey(bin)) {
+            distributionMap.put(bin, observationFrequency);
+        }
+        else {
+            long oldFrequency = Long.parseLong(distributionMap.get(bin).toString());
+            distributionMap.replace(bin, oldFrequency + observationFrequency);
+        }
+    }
+
     public static void main(String[] args) {
         new Histogram();
     }

libraries/src/main/java/com/baeldung/ftp/FtpClient.java

@@ -0,0 +1,63 @@
+package com.baeldung.ftp;
+
+import org.apache.commons.net.PrintCommandListener;
+import org.apache.commons.net.ftp.FTPClient;
+import org.apache.commons.net.ftp.FTPFile;
+import org.apache.commons.net.ftp.FTPReply;
+
+import java.io.*;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.stream.Collectors;
+
+class FtpClient {
+
+    private final String server;
+    private final int port;
+    private final String user;
+    private final String password;
+    private FTPClient ftp;
+
+    FtpClient(String server, int port, String user, String password) {
+        this.server = server;
+        this.port = port;
+        this.user = user;
+        this.password = password;
+    }
+
+    void open() throws IOException {
+        ftp = new FTPClient();
+
+        ftp.addProtocolCommandListener(new PrintCommandListener(new PrintWriter(System.out)));
+
+        ftp.connect(server, port);
+        int reply = ftp.getReplyCode();
+        if (!FTPReply.isPositiveCompletion(reply)) {
+            ftp.disconnect();
+            throw new IOException("Exception in connecting to FTP Server");
+        }
+
+        ftp.login(user, password);
+    }
+
+    void close() throws IOException {
+        ftp.disconnect();
+    }
+
+    Collection<String> listFiles(String path) throws IOException {
+        FTPFile[] files = ftp.listFiles(path);
+
+        return Arrays.stream(files)
+                .map(FTPFile::getName)
+                .collect(Collectors.toList());
+    }
+
+    void putFileToPath(File file, String path) throws IOException {
+        ftp.storeFile(path, new FileInputStream(file));
+    }
+
+    void downloadFile(String source, String destination) throws IOException {
+        FileOutputStream out = new FileOutputStream(destination);
+        ftp.retrieveFile(source, out);
+    }
+}

libraries/src/main/java/com/baeldung/javalin/User/UserController.java

@@ -14,7 +14,7 @@ public class UserController {
     public static Handler fetchById = ctx -> {
         int id = Integer.parseInt(Objects.requireNonNull(ctx.param("id")));
         UserDao dao = UserDao.instance();
-        User user = dao.getUserById(id);
+        User user = dao.getUserById(id).get();
         if (user == null) {
             ctx.html("Not Found");
         } else {

libraries/src/test/java/com/baeldung/ftp/FtpClientIntegrationTest.java

@@ -0,0 +1,73 @@
+package com.baeldung.ftp;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockftpserver.fake.FakeFtpServer;
+import org.mockftpserver.fake.UserAccount;
+import org.mockftpserver.fake.filesystem.DirectoryEntry;
+import org.mockftpserver.fake.filesystem.FileEntry;
+import org.mockftpserver.fake.filesystem.FileSystem;
+import org.mockftpserver.fake.filesystem.UnixFakeFileSystem;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.util.Collection;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class FtpClientIntegrationTest {
+
+    private FakeFtpServer fakeFtpServer;
+
+    private FtpClient ftpClient;
+
+    @Before
+    public void setup() throws IOException {
+        fakeFtpServer = new FakeFtpServer();
+        fakeFtpServer.addUserAccount(new UserAccount("user", "password", "/data"));
+
+        FileSystem fileSystem = new UnixFakeFileSystem();
+        fileSystem.add(new DirectoryEntry("/data"));
+        fileSystem.add(new FileEntry("/data/foobar.txt", "abcdef 1234567890"));
+        fakeFtpServer.setFileSystem(fileSystem);
+        fakeFtpServer.setServerControlPort(0);
+
+        fakeFtpServer.start();
+
+        ftpClient = new FtpClient("localhost", fakeFtpServer.getServerControlPort(), "user", "password");
+        ftpClient.open();
+    }
+
+    @After
+    public void teardown() throws IOException {
+        ftpClient.close();
+        fakeFtpServer.stop();
+    }
+
+    @Test
+    public void givenRemoteFile_whenListingRemoteFiles_thenItIsContainedInList() throws IOException {
+        Collection<String> files = ftpClient.listFiles("");
+
+        assertThat(files).contains("foobar.txt");
+    }
+
+    @Test
+    public void givenRemoteFile_whenDownloading_thenItIsOnTheLocalFilesystem() throws IOException {
+        ftpClient.downloadFile("/foobar.txt", "downloaded_buz.txt");
+
+        assertThat(new File("downloaded_buz.txt")).exists();
+        new File("downloaded_buz.txt").delete(); // cleanup
+    }
+
+    @Test
+    public void givenLocalFile_whenUploadingIt_thenItExistsOnRemoteLocation() throws URISyntaxException, IOException {
+        File file = new File(getClass().getClassLoader().getResource("ftp/baz.txt").toURI());
+
+        ftpClient.putFileToPath(file, "/buz.txt");
+
+        assertThat(fakeFtpServer.getFileSystem().exists("/buz.txt")).isTrue();
+    }
+
+}

libraries/src/test/java/com/baeldung/ftp/JdkFtpClientIntegrationTest.java

@@ -0,0 +1,63 @@
+package com.baeldung.ftp;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockftpserver.fake.FakeFtpServer;
+import org.mockftpserver.fake.UserAccount;
+import org.mockftpserver.fake.filesystem.DirectoryEntry;
+import org.mockftpserver.fake.filesystem.FileEntry;
+import org.mockftpserver.fake.filesystem.FileSystem;
+import org.mockftpserver.fake.filesystem.UnixFakeFileSystem;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.nio.file.Files;
+import java.util.Collection;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class JdkFtpClientIntegrationTest {
+
+    private FakeFtpServer fakeFtpServer;
+
+
+    @Before
+    public void setup() throws IOException {
+        fakeFtpServer = new FakeFtpServer();
+        fakeFtpServer.addUserAccount(new UserAccount("user", "password", "/data"));
+
+        FileSystem fileSystem = new UnixFakeFileSystem();
+        fileSystem.add(new DirectoryEntry("/data"));
+        fileSystem.add(new FileEntry("/data/foobar.txt", "abcdef 1234567890"));
+        fakeFtpServer.setFileSystem(fileSystem);
+        fakeFtpServer.setServerControlPort(0);
+
+        fakeFtpServer.start();
+    }
+
+    @After
+    public void teardown() throws IOException {
+        fakeFtpServer.stop();
+    }
+
+    @Test
+    public void givenRemoteFile_whenDownloading_thenItIsOnTheLocalFilesystem() throws IOException {
+        String ftpUrl = String.format("ftp://user:password@localhost:%d/foobar.txt", fakeFtpServer.getServerControlPort());
+
+        URLConnection urlConnection = new URL(ftpUrl).openConnection();
+        InputStream inputStream = urlConnection.getInputStream();
+        Files.copy(inputStream, new File("downloaded_buz.txt").toPath());
+        inputStream.close();
+
+        assertThat(new File("downloaded_buz.txt")).exists();
+
+        new File("downloaded_buz.txt").delete(); // cleanup
+    }
+
+}