Merge remote-tracking branch 'eugenp/master'

cas/cas-secured-app/README.md

@@ -0,0 +1,2 @@
+## Relevant articles:
+- [CAS SSO With Spring Security](http://www.baeldung.com/spring-security-cas-sso)

cas/cas-secured-app/pom.xml

@@ -14,7 +14,7 @@
 	<parent>
 		<groupId>org.springframework.boot</groupId>
 		<artifactId>spring-boot-starter-parent</artifactId>
-		<version>2.0.0.BUILD-SNAPSHOT</version>
+		<version>2.0.0.M7</version>
 		<relativePath/> <!-- lookup parent from repository -->
 	</parent>
 
@@ -87,14 +87,6 @@
 	</build>
 
 	<repositories>
-		<repository>
-			<id>spring-snapshots</id>
-			<name>Spring Snapshots</name>
-			<url>https://repo.spring.io/snapshot</url>
-			<snapshots>
-				<enabled>true</enabled>
-			</snapshots>
-		</repository>
 		<repository>
 			<id>spring-milestones</id>
 			<name>Spring Milestones</name>
@@ -106,14 +98,6 @@
 	</repositories>
 
 	<pluginRepositories>
-		<pluginRepository>
-			<id>spring-snapshots</id>
-			<name>Spring Snapshots</name>
-			<url>https://repo.spring.io/snapshot</url>
-			<snapshots>
-				<enabled>true</enabled>
-			</snapshots>
-		</pluginRepository>
 		<pluginRepository>
 			<id>spring-milestones</id>
 			<name>Spring Milestones</name>

cas/cas-secured-app/src/main/java/com/baeldung/cassecuredapp/controllers/AuthController.java

@@ -1,6 +1,7 @@
 package com.baeldung.cassecuredapp.controllers;
 
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
 import org.springframework.security.core.Authentication;
 import org.springframework.security.core.context.SecurityContextHolder;
 import org.springframework.security.web.authentication.logout.CookieClearingLogoutHandler;
@@ -15,7 +16,7 @@ import javax.servlet.http.HttpServletResponse;
 @Controller
 public class AuthController {
 
-    private Logger logger = Logger.getLogger(AuthController.class);
+    private Logger logger = LogManager.getLogger(AuthController.class);
 
     @GetMapping("/logout")
     public String logout(

core-java-8/README.md

@@ -32,3 +32,4 @@
 - [“Stream has already been operated upon or closed” Exception in Java](http://www.baeldung.com/java-stream-operated-upon-or-closed-exception)
 - [Display All Time Zones With GMT And UTC in Java](http://www.baeldung.com/java-time-zones)
 - [Copy a File with Java](http://www.baeldung.com/java-copy-file)
+- [Generating Prime Numbers in Java](http://www.baeldung.com/java-generate-prime-numbers)

core-java-8/pom.xml

@@ -83,6 +83,24 @@
             <scope>test</scope>
         </dependency>
         
+        <dependency>
+		    <groupId>org.openjdk.jmh</groupId>
+		    <artifactId>jmh-core</artifactId>
+		    <version>1.19</version>
+		</dependency>
+		
+		<dependency>
+		    <groupId>org.openjdk.jmh</groupId>
+		    <artifactId>jmh-generator-annprocess</artifactId>
+		    <version>1.19</version>
+		</dependency>
+		
+		<dependency>
+		    <groupId>org.openjdk.jmh</groupId>
+		    <artifactId>jmh-generator-bytecode</artifactId>
+		    <version>1.19</version>
+		</dependency>
+
     </dependencies>
 
     <build>

core-java-8/src/main/java/com/baeldung/datetime/UseDuration.java

@@ -2,7 +2,6 @@ package com.baeldung.datetime;
 
 import java.time.Duration;
 import java.time.LocalTime;
-import java.time.Period;
 
 public class UseDuration {
 

core-java-8/src/main/java/com/baeldung/stream/PrimitiveStreams.java

@@ -0,0 +1,23 @@
+package com.baeldung.stream;
+
+import java.util.Arrays;
+import java.util.stream.IntStream;
+
+class PrimitiveStreams {
+
+    int min(int[] integers) {
+        return Arrays.stream(integers).min().getAsInt();
+    }
+
+    int max(int... integers) {
+        return IntStream.of(integers).max().getAsInt();
+    }
+
+    int sum(int... integers) {
+        return IntStream.of(integers).sum();
+    }
+
+    double avg(int... integers) {
+        return IntStream.of(integers).average().getAsDouble();
+    }
+}

core-java-8/src/main/java/com/baeldung/streamApi/Product.java

@@ -1,8 +1,6 @@
 package com.baeldung.streamApi;
 
 import java.util.List;
-import java.util.Optional;
-import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
 /**

core-java-8/src/test/java/com/baeldung/counter/CounterStatistics.java

@@ -0,0 +1,45 @@
+package com.baeldung.counter;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Mode;
+
+import com.baeldung.counter.CounterUtil.MutableInteger;
+
+@Fork(value = 1, warmups = 3)
+@BenchmarkMode(Mode.All)
+public class CounterStatistics {
+
+    private static final Map<String, Integer> counterMap = new HashMap<>();
+    private static final Map<String, MutableInteger> counterWithMutableIntMap = new HashMap<>();
+    private static final Map<String, int[]> counterWithIntArrayMap = new HashMap<>();
+    private static final Map<String, Long> counterWithLongWrapperMap = new HashMap<>();
+
+    @Benchmark
+    public void wrapperAsCounter() {
+        CounterUtil.counterWithWrapperObject(counterMap);
+    }
+
+    @Benchmark
+    public void lambdaExpressionWithWrapper() {
+        CounterUtil.counterWithLambdaAndWrapper(counterWithLongWrapperMap);
+    }
+
+    @Benchmark
+    public void mutableIntegerAsCounter() {
+        CounterUtil.counterWithMutableInteger(counterWithMutableIntMap);
+    }
+
+    @Benchmark
+    public void primitiveArrayAsCounter() {
+        CounterUtil.counterWithPrimitiveArray(counterWithIntArrayMap);
+    }
+
+    public static void main(String[] args) throws Exception {
+        org.openjdk.jmh.Main.main(args);
+    }
+}

core-java-8/src/test/java/com/baeldung/counter/CounterTest.java

@@ -0,0 +1,53 @@
+package com.baeldung.counter;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import com.baeldung.counter.CounterUtil.MutableInteger;
+
+public class CounterTest {
+
+    @Test
+    public void whenMapWithWrapperAsCounter_runsSuccessfully() {
+        Map<String, Integer> counterMap = new HashMap<>();
+        CounterUtil.counterWithWrapperObject(counterMap);
+
+        assertEquals(3, counterMap.get("China")
+            .intValue());
+        assertEquals(2, counterMap.get("India")
+            .intValue());
+    }
+
+    @Test
+    public void whenMapWithLambdaAndWrapperCounter_runsSuccessfully() {
+        Map<String, Long> counterMap = new HashMap<>();
+        CounterUtil.counterWithLambdaAndWrapper(counterMap);
+
+        assertEquals(3l, counterMap.get("China")
+            .longValue());
+        assertEquals(2l, counterMap.get("India")
+            .longValue());
+    }
+
+    @Test
+    public void whenMapWithMutableIntegerCounter_runsSuccessfully() {
+        Map<String, MutableInteger> counterMap = new HashMap<>();
+        CounterUtil.counterWithMutableInteger(counterMap);
+        assertEquals(3, counterMap.get("China")
+            .getCount());
+        assertEquals(2, counterMap.get("India")
+            .getCount());
+    }
+
+    @Test
+    public void whenMapWithPrimitiveArray_runsSuccessfully() {
+        Map<String, int[]> counterMap = new HashMap<>();
+        CounterUtil.counterWithPrimitiveArray(counterMap);
+        assertEquals(3, counterMap.get("China")[0]);
+        assertEquals(2, counterMap.get("India")[0]);
+    }
+}

core-java-8/src/test/java/com/baeldung/counter/CounterUtil.java

@@ -0,0 +1,52 @@
+package com.baeldung.counter;
+
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class CounterUtil {
+
+    private final static String[] COUNTRY_NAMES = { "China", "Australia", "India", "USA", "USSR", "UK", "China", "France", "Poland", "Austria", "India", "USA", "Egypt", "China" };
+
+    public static void counterWithWrapperObject(Map<String, Integer> counterMap) {
+        for (String country : COUNTRY_NAMES) {
+            counterMap.compute(country, (k, v) -> v == null ? 1 : v + 1);
+        }
+    }
+
+    public static void counterWithLambdaAndWrapper(Map<String, Long> counterMap) {
+        counterMap.putAll(Stream.of(COUNTRY_NAMES)
+            .parallel()
+            .collect(Collectors.groupingBy(k -> k, Collectors.counting())));
+    }
+
+    public static class MutableInteger {
+        int count;
+
+        public MutableInteger(int count) {
+            this.count = count;
+        }
+
+        public void increment() {
+            this.count++;
+        }
+
+        public int getCount() {
+            return this.count;
+        }
+    }
+
+    public static void counterWithMutableInteger(Map<String, MutableInteger> counterMap) {
+        for (String country : COUNTRY_NAMES) {
+            counterMap.compute(country, (k, v) -> v == null ? new MutableInteger(0) : v)
+                .increment();
+        }
+    }
+
+    public static void counterWithPrimitiveArray(Map<String, int[]> counterMap) {
+        for (String country : COUNTRY_NAMES) {
+            counterMap.compute(country, (k, v) -> v == null ? new int[] { 0 } : v)[0]++;
+        }
+    }
+
+}

core-java-8/src/test/java/com/baeldung/datetime/UseLocalDateTimeUnitTest.java

@@ -4,7 +4,6 @@ import java.time.LocalDate;
 import java.time.LocalTime;
 import java.time.Month;
 
-import org.junit.Assert;
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;

core-java-8/src/test/java/com/baeldung/datetime/UseLocalDateUnitTest.java

@@ -4,7 +4,6 @@ import java.time.DayOfWeek;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 
-import org.junit.Assert;
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;

core-java-8/src/test/java/com/baeldung/java8/comparator/Java8ComparatorUnitTest.java

@@ -6,7 +6,6 @@ import java.util.Comparator;
 import org.junit.Before;
 import org.junit.Test;
 
-import lombok.Data;
 import static org.junit.Assert.assertTrue;
 
 public class Java8ComparatorUnitTest {
@@ -134,8 +133,7 @@ public class Java8ComparatorUnitTest {
 
     @Test
     public void whenThenComparing_thenSortedByAgeName() {
-        Comparator<Employee> employee_Age_Name_Comparator = Comparator.comparing(Employee::getAge)
-            .thenComparing(Employee::getName);
+        Comparator<Employee> employee_Age_Name_Comparator = Comparator.comparing(Employee::getAge).thenComparing(Employee::getName);
 
         Arrays.sort(someMoreEmployees, employee_Age_Name_Comparator);
         // System.out.println(Arrays.toString(someMoreEmployees));
@@ -144,8 +142,7 @@ public class Java8ComparatorUnitTest {
 
     @Test
     public void whenThenComparing_thenSortedByNameAge() {
-        Comparator<Employee> employee_Name_Age_Comparator = Comparator.comparing(Employee::getName)
-            .thenComparingInt(Employee::getAge);
+        Comparator<Employee> employee_Name_Age_Comparator = Comparator.comparing(Employee::getName).thenComparingInt(Employee::getAge);
 
         Arrays.sort(someMoreEmployees, employee_Name_Age_Comparator);
         // System.out.println(Arrays.toString(someMoreEmployees));

core-java-8/src/test/java/com/baeldung/stream/PrimitiveStreamsUnitTest.java

@@ -0,0 +1,96 @@
+package com.baeldung.stream;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class PrimitiveStreamsUnitTest {
+
+    private PrimitiveStreams streams = new PrimitiveStreams();
+
+    @Test
+    public void givenAnArrayOfIntegersWhenMinIsCalledThenCorrectMinIsReturned() {
+        int[] integers = new int[] {20, 98, 12, 7, 35};
+        int min = streams.min(integers); // returns 7
+
+        assertEquals(7, min);
+    }
+
+    @Test
+    public void givenAnArrayOfIntegersWhenMaxIsCalledThenCorrectMaxIsReturned() {
+        int max = streams.max(20, 98, 12, 7, 35);
+
+        assertEquals(98, max);
+    }
+
+    @Test
+    public void givenAnArrayOfIntegersWhenSumIsCalledThenCorrectSumIsReturned() {
+        int sum = streams.sum(20, 98, 12, 7, 35);
+
+        assertEquals(172, sum);
+    }
+
+    @Test
+    public void givenAnArrayOfIntegersWhenAvgIsCalledThenCorrectAvgIsReturned() {
+        double avg = streams.avg(20, 98, 12, 7, 35);
+
+        assertTrue(34.4 == avg);
+    }
+
+    @Test
+    public void givenARangeOfIntegersWhenIntStreamSumIsCalledThenCorrectSumIsReturned() {
+        int sum = IntStream.range(1, 10).sum();
+
+        assertEquals(45, sum);
+    }
+
+    @Test
+    public void givenARangeClosedOfIntegersWhenIntStreamSumIsCalledThenCorrectSumIsReturned() {
+        int sum = IntStream.rangeClosed(1, 10).sum();
+
+        assertEquals(55, sum);
+    }
+
+    @Test
+    public void givenARangeWhenForEachIsCalledThenTheIndicesWillBePrinted() {
+        IntStream.rangeClosed(1, 5).parallel().forEach(System.out::println);
+    }
+
+    @Test
+    public void givenAnArrayWhenSumIsCalledThenTheCorrectSumIsReturned() {
+
+        int sum = Arrays.asList(33,45).stream().mapToInt(a -> a).sum();
+
+        assertEquals(78, sum);
+    }
+
+    @Test
+    public void givenAnIntStreamThenGetTheEvenIntegers() {
+        List<Integer> evenInts = IntStream.rangeClosed(1, 10)
+          .filter(i -> i % 2 == 0)
+          .boxed()
+          .collect(Collectors.toList());
+
+        List<Integer> expected = IntStream.of(2, 4, 6, 8, 10).boxed().collect(Collectors.toList());
+
+        assertEquals(expected, evenInts);
+    }
+
+    class Person {
+        private int age;
+
+        Person(int age) {
+            this.age = age;
+        }
+
+        int getAge() {
+            return age;
+        }
+    }
+}

core-java-8/src/test/java/com/baeldung/temporaladjusters/CustomTemporalAdjusterTest.java

@@ -1,7 +1,6 @@
 package com.baeldung.temporaladjusters;
 
 import com.baeldung.temporaladjuster.CustomTemporalAdjuster;
-import org.junit.Assert;
 import org.junit.Test;
 
 import java.time.LocalDate;

core-java-9/README.md

@@ -18,3 +18,4 @@
 - [How to Get All Dates Between Two Dates?](http://www.baeldung.com/java-between-dates)
 - [Java 9 java.util.Objects Additions](http://www.baeldung.com/java-9-objects-new)
 - [Compact Strings in Java 9](http://www.baeldung.com/java-9-compact-string)
+- [Convert Date to LocalDate or LocalDateTime and Back](http://www.baeldung.com/java-date-to-localdate-and-localdatetime)

core-java-9/compile-httpclient.bat

@@ -0,0 +1,3 @@
+javac --module-path mods -d mods/com.baeldung.httpclient^
+ src/modules/com.baeldung.httpclient/module-info.java^
+ src/modules/com.baeldung.httpclient/com/baeldung/httpclient/HttpClientExample.java

core-java-9/run-httpclient.bat

@@ -0,0 +1 @@
+java --module-path mods -m com.baeldung.httpclient/com.baeldung.httpclient.HttpClientExample

core-java-9/src/modules/com.baeldung.httpclient/com/baeldung/httpclient/HttpClientExample.java

@@ -0,0 +1,84 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package com.baeldung.httpclient;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+import jdk.incubator.http.HttpClient;
+import jdk.incubator.http.HttpRequest;
+import jdk.incubator.http.HttpRequest.BodyProcessor;
+import jdk.incubator.http.HttpResponse;
+import jdk.incubator.http.HttpResponse.BodyHandler;
+
+/**
+ *
+ * @author pkaria
+ */
+public class HttpClientExample {
+    
+    public static void main(String[] args) throws Exception {
+        httpGetRequest();
+        httpPostRequest();
+        asynchronousRequest();
+        asynchronousMultipleRequests();
+    }
+
+    public static void httpGetRequest() throws URISyntaxException, IOException, InterruptedException {
+        HttpClient client = HttpClient.newHttpClient();
+        URI httpURI = new URI("http://jsonplaceholder.typicode.com/posts/1");
+        HttpRequest request = HttpRequest.newBuilder(httpURI).GET()
+          .headers("Accept-Enconding", "gzip, deflate").build();
+        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandler.asString());
+        String responseBody = response.body();
+        int responseStatusCode = response.statusCode();
+        System.out.println(responseBody);
+    }
+
+    public static void httpPostRequest() throws URISyntaxException, IOException, InterruptedException {
+        HttpClient client = HttpClient
+                .newBuilder()
+                .build();
+        HttpRequest request = HttpRequest
+                .newBuilder(new URI("http://jsonplaceholder.typicode.com/posts"))
+                .POST(BodyProcessor.fromString("Sample Post Request"))
+                .build();
+        HttpResponse<String> response
+                = client.send(request, HttpResponse.BodyHandler.asString());
+        String responseBody = response.body();
+        System.out.println(responseBody);
+    }
+
+    public static void asynchronousRequest() throws URISyntaxException {
+        HttpClient client = HttpClient.newHttpClient();
+        URI httpURI = new URI("http://jsonplaceholder.typicode.com/posts/1");
+        HttpRequest request = HttpRequest.newBuilder(httpURI).GET().build();
+        CompletableFuture<HttpResponse<String>> futureResponse = client.sendAsync(request,
+                HttpResponse.BodyHandler.asString());
+    }
+
+    public static void asynchronousMultipleRequests() throws URISyntaxException {
+        List<URI> targets = Arrays.asList(new URI("http://jsonplaceholder.typicode.com/posts/1"), new URI("http://jsonplaceholder.typicode.com/posts/2"));
+        HttpClient client = HttpClient.newHttpClient();
+        List<CompletableFuture<File>> futures = targets
+                .stream()
+                .map(target -> client
+                .sendAsync(
+                        HttpRequest.newBuilder(target)
+                                .GET()
+                                .build(),
+                        BodyHandler.asFile(Paths.get("base", target.getPath())))
+                .thenApply(response -> response.body())
+                .thenApply(path -> path.toFile()))
+                .collect(Collectors.toList());
+    }
+}

core-java-9/src/modules/com.baeldung.httpclient/module-info.java

@@ -0,0 +1,3 @@
+module com.baeldung.httpclient {   
+	requires jdk.incubator.httpclient;
+}

core-java-9/src/test/java/com/baeldung/java9/varhandles/VariableHandlesTest.java

@@ -0,0 +1,106 @@
+package com.baeldung.java9.varhandles;
+
+import org.junit.Test;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class VariableHandlesTest {
+
+    public int publicTestVariable = 1;
+    private int privateTestVariable = 1;
+    public int variableToSet = 1;
+    public int variableToCompareAndSet = 1;
+    public int variableToGetAndAdd = 0;
+    public byte variableToBitwiseOr = 0;
+
+    @Test
+    public void whenVariableHandleForPublicVariableIsCreated_ThenItIsInitializedProperly() throws NoSuchFieldException, IllegalAccessException {
+        VarHandle publicIntHandle = MethodHandles
+          .lookup()
+          .in(VariableHandlesTest.class)
+          .findVarHandle(VariableHandlesTest.class, "publicTestVariable", int.class);
+
+        assertThat(publicIntHandle.coordinateTypes().size() == 1);
+        assertThat(publicIntHandle.coordinateTypes().get(0) == VariableHandles.class);
+
+    }
+
+    @Test
+    public void whenVariableHandleForPrivateVariableIsCreated_ThenItIsInitializedProperly() throws NoSuchFieldException, IllegalAccessException {
+        VarHandle privateIntHandle = MethodHandles
+          .privateLookupIn(VariableHandlesTest.class, MethodHandles.lookup())
+          .findVarHandle(VariableHandlesTest.class, "privateTestVariable", int.class);
+
+        assertThat(privateIntHandle.coordinateTypes().size() == 1);
+        assertThat(privateIntHandle.coordinateTypes().get(0) == VariableHandlesTest.class);
+
+    }
+
+    @Test
+    public void whenVariableHandleForArrayVariableIsCreated_ThenItIsInitializedProperly() throws NoSuchFieldException, IllegalAccessException {
+        VarHandle arrayVarHandle = MethodHandles
+          .arrayElementVarHandle(int[].class);
+
+        assertThat(arrayVarHandle.coordinateTypes().size() == 2);
+        assertThat(arrayVarHandle.coordinateTypes().get(0) == int[].class);
+    }
+
+    @Test
+    public void givenVarHandle_whenGetIsInvoked_ThenValueOfVariableIsReturned() throws NoSuchFieldException, IllegalAccessException {
+        VarHandle publicIntHandle = MethodHandles
+          .lookup()
+          .in(VariableHandlesTest.class)
+          .findVarHandle(VariableHandlesTest.class, "publicTestVariable", int.class);
+
+        assertThat((int) publicIntHandle.get(this) == 1);
+    }
+
+    @Test
+    public void givenVarHandle_whenSetIsInvoked_ThenValueOfVariableIsChanged() throws NoSuchFieldException, IllegalAccessException {
+        VarHandle publicIntHandle = MethodHandles
+          .lookup()
+          .in(VariableHandlesTest.class)
+          .findVarHandle(VariableHandlesTest.class, "variableToSet", int.class);
+        publicIntHandle.set(this, 15);
+
+        assertThat((int) publicIntHandle.get(this) == 15);
+    }
+
+    @Test
+    public void givenVarHandle_whenCompareAndSetIsInvoked_ThenValueOfVariableIsChanged() throws NoSuchFieldException, IllegalAccessException {
+        VarHandle publicIntHandle = MethodHandles
+          .lookup()
+          .in(VariableHandlesTest.class)
+          .findVarHandle(VariableHandlesTest.class, "variableToCompareAndSet", int.class);
+        publicIntHandle.compareAndSet(this, 1, 100);
+
+        assertThat((int) publicIntHandle.get(this) == 100);
+    }
+
+    @Test
+    public void givenVarHandle_whenGetAndAddIsInvoked_ThenValueOfVariableIsChanged() throws NoSuchFieldException, IllegalAccessException {
+        VarHandle publicIntHandle = MethodHandles
+          .lookup()
+          .in(VariableHandlesTest.class)
+          .findVarHandle(VariableHandlesTest.class, "variableToGetAndAdd", int.class);
+        int before = (int) publicIntHandle.getAndAdd(this, 200);
+
+        assertThat(before == 0);
+        assertThat((int) publicIntHandle.get(this) == 200);
+    }
+
+    @Test
+    public void givenVarHandle_whenGetAndBitwiseOrIsInvoked_ThenValueOfVariableIsChanged() throws NoSuchFieldException, IllegalAccessException {
+        VarHandle publicIntHandle = MethodHandles
+          .lookup()
+          .in(VariableHandlesTest.class)
+          .findVarHandle(VariableHandlesTest.class, "variableToBitwiseOr", byte.class);
+        byte before = (byte) publicIntHandle.getAndBitwiseOr(this, (byte) 127);
+
+        assertThat(before == 0);
+        assertThat(variableToBitwiseOr == 127);
+    }
+}

core-java-concurrency/README.md

@@ -31,3 +31,5 @@
 - [Overview of the java.util.concurrent](http://www.baeldung.com/java-util-concurrent)
 - [Semaphores in Java](http://www.baeldung.com/java-semaphore)
 - [Daemon Threads in Java](http://www.baeldung.com/java-daemon-thread)
+- [Implementing a Runnable vs Extending a Thread](http://www.baeldung.com/java-runnable-vs-extending-thread)
+- [How to Kill a Java Thread](http://www.baeldung.com/java-thread-stop)

core-java-concurrency/src/main/java/com/baeldung/concurrent/waitandnotify/Data.java

@@ -0,0 +1,33 @@
+package com.baeldung.concurrent.waitandnotify;
+
+public class Data {
+    private String packet;
+    
+    // True if receiver should wait
+    // False if sender should wait
+    private boolean transfer = true;
+ 
+    public synchronized String receive() {
+        while (transfer) {
+            try {
+                wait();
+            } catch (InterruptedException e) {}
+        }
+        transfer = true;
+
+        notifyAll();
+        return packet;
+    }
+ 
+    public synchronized void send(String packet) {
+        while (!transfer) {
+            try { 
+                wait();
+            } catch (InterruptedException e) {}
+        }
+        transfer = false;
+        
+        this.packet = packet;
+        notifyAll();
+    }
+}

core-java-concurrency/src/main/java/com/baeldung/concurrent/waitandnotify/NetworkDriver.java

@@ -0,0 +1,12 @@
+package com.baeldung.concurrent.waitandnotify;
+
+public class NetworkDriver {
+    public static void main(String[] args) {
+        Data data = new Data();
+        Thread sender = new Thread(new Sender(data));
+        Thread receiver = new Thread(new Receiver(data));
+        
+        sender.start();
+        receiver.start();
+    }
+}

core-java-concurrency/src/main/java/com/baeldung/concurrent/waitandnotify/Receiver.java

@@ -0,0 +1,25 @@
+package com.baeldung.concurrent.waitandnotify;
+
+import java.util.concurrent.ThreadLocalRandom;
+
+public class Receiver implements Runnable {
+    private Data load;
+ 
+    public Receiver(Data load) {
+        this.load = load;
+    }
+ 
+    public void run() {
+        for(String receivedMessage = load.receive();
+          !"End".equals(receivedMessage) ;
+          receivedMessage = load.receive()) {
+            
+            System.out.println(receivedMessage);
+
+            //Thread.sleep() to mimic heavy server-side processing
+            try {
+                Thread.sleep(ThreadLocalRandom.current().nextInt(1000, 5000));
+            } catch (InterruptedException e) {}
+        }
+    }
+}

core-java-concurrency/src/main/java/com/baeldung/concurrent/waitandnotify/Sender.java

@@ -0,0 +1,30 @@
+package com.baeldung.concurrent.waitandnotify;
+
+import java.util.concurrent.ThreadLocalRandom;
+
+public class Sender implements Runnable {
+    private Data data;
+ 
+    public Sender(Data data) {
+        this.data = data;
+    }
+ 
+    public void run() {
+        String packets[] = {
+            "First packet",
+            "Second packet",
+            "Third packet",
+            "Fourth packet",
+            "End"
+        };
+ 
+        for (String packet : packets) {
+            data.send(packet);
+            
+            //Thread.sleep() to mimic heavy server-side processing
+            try {
+                Thread.sleep(ThreadLocalRandom.current().nextInt(1000, 5000));
+            } catch (InterruptedException e) {}
+        }
+    }
+}

core-java-concurrency/src/test/java/com/baeldung/concurrent/executorservice/WaitingForThreadsToFinishManualTest.java

@@ -9,11 +9,10 @@ import java.util.List;
 import java.util.concurrent.*;
 
 import static junit.framework.TestCase.assertTrue;
-import static org.junit.Assert.fail;
 
-public class WaitingForThreadsToFinishTest {
+public class WaitingForThreadsToFinishManualTest {
 
-    private static final Logger LOG = LoggerFactory.getLogger(WaitingForThreadsToFinishTest.class);
+    private static final Logger LOG = LoggerFactory.getLogger(WaitingForThreadsToFinishManualTest.class);
     private final static ExecutorService WORKER_THREAD_POOL = Executors.newFixedThreadPool(10);
 
     public void awaitTerminationAfterShutdown(ExecutorService threadPool) {
@@ -40,9 +39,7 @@ public class WaitingForThreadsToFinishTest {
             CountDownLatch latch = new CountDownLatch(2);
             
             for (int i = 0; i < 2; i++) {
-                WORKER_THREAD_POOL.submit(new Runnable() {                
-                    @Override
-                    public void run() {
+                WORKER_THREAD_POOL.submit(() -> {
                     try {
                         Thread.sleep(1000);
                         latch.countDown();
@@ -50,7 +47,6 @@ public class WaitingForThreadsToFinishTest {
                         e.printStackTrace();
                         Thread.currentThread().interrupt();
                     }
-                    }
                 });
             }
 
@@ -83,13 +79,9 @@ public class WaitingForThreadsToFinishTest {
             awaitTerminationAfterShutdown(WORKER_THREAD_POOL);
 
             try {
-                WORKER_THREAD_POOL.submit(new Callable<String>() {
-                    @Override
-                    public String call() throws Exception {
-                        fail("This thread should have been rejected !");
+                WORKER_THREAD_POOL.submit((Callable<String>) () -> {
                     Thread.sleep(1000000);
                     return null;
-                    }
                 });
             } catch (RejectedExecutionException ex) {
                 //
@@ -150,66 +142,4 @@ public class WaitingForThreadsToFinishTest {
             awaitTerminationAfterShutdown(WORKER_THREAD_POOL);
         }
     }
-
-    @Test
-    public void givenMultipleThreads_whenUsingCompletableFutures_thenMainThreadShouldWaitForAllToFinish() {
-
-        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
-
-            try {
-                Thread.sleep(1000);
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-
-            return "Hello";
-        });
-
-        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
-
-            try {
-                Thread.sleep(5000);
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-
-            return "Beautiful";
-        });
-
-        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
-
-            try {
-                Thread.sleep(3000);
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-
-            return "World";
-        });
-
-        long startProcessingTime = System.currentTimeMillis();
-        CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(future1, future2, future3);
-        combinedFuture.join();
-
-        long totalProcessingTime = System.currentTimeMillis() - startProcessingTime;
-        assertTrue(totalProcessingTime >= 5000 && totalProcessingTime < 6000);
-
-        LOG.debug("Responses from all threads are available after " + totalProcessingTime + " milliseconds");
-
-        try {
-            String thread1Response = future1.get();
-            assertTrue(thread1Response.equals("Hello"));
-
-            String thread2Response = future2.get();
-            assertTrue(thread2Response.equals("Beautiful"));
-
-            String thread3Response = future3.get();
-            assertTrue(thread3Response.equals("World"));
-
-        } catch (InterruptedException | ExecutionException e) {
-            e.printStackTrace();
-        }
-
-        awaitTerminationAfterShutdown(WORKER_THREAD_POOL);
-    }
 }

core-java-concurrency/src/test/java/com/baeldung/concurrent/waitandnotify/NetworkIntegrationTest.java

@@ -0,0 +1,65 @@
+package com.baeldung.concurrent.waitandnotify;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class NetworkIntegrationTest {
+
+	private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();
+	private final ByteArrayOutputStream errContent = new ByteArrayOutputStream();
+	private String expected;
+	
+	@Before
+	public void setUpStreams() {
+	    System.setOut(new PrintStream(outContent));
+	    System.setErr(new PrintStream(errContent));
+	}
+	
+	@Before
+	public void setUpExpectedOutput() {
+		StringWriter expectedStringWriter = new StringWriter();
+		
+		PrintWriter printWriter = new PrintWriter(expectedStringWriter);
+		printWriter.println("First packet");
+		printWriter.println("Second packet");
+		printWriter.println("Third packet");
+		printWriter.println("Fourth packet");
+		printWriter.close();
+		
+		expected = expectedStringWriter.toString();
+	}
+
+	@After
+	public void cleanUpStreams() {
+	    System.setOut(null);
+	    System.setErr(null);
+	}
+	
+	@Test
+	public void givenSenderAndReceiver_whenSendingPackets_thenNetworkSynchronized() {
+        Data data = new Data();
+        Thread sender = new Thread(new Sender(data));
+        Thread receiver = new Thread(new Receiver(data));
+        
+        sender.start();
+        receiver.start();
+        
+        //wait for sender and receiver to finish before we test against expected
+        try {
+			sender.join();
+			receiver.join();
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+		
+	    assertEquals(expected, outContent.toString());
+	}
+}

core-java/README.md

@@ -120,4 +120,10 @@
 - [Guide to Java String Pool](http://www.baeldung.com/java-string-pool)
 - [Copy a File with Java](http://www.baeldung.com/java-copy-file)
 - [Introduction to Creational Design Patterns](http://www.baeldung.com/creational-design-patterns)
-
+- [Quick Example - Comparator vs Comparable in Java](http://www.baeldung.com/java-comparator-comparable)
+- [Quick Guide to Java Stack](http://www.baeldung.com/java-stack)
+- [The Java continue and break Keywords](http://www.baeldung.com/java-continue-and-break)
+- [Java – Append Data to a File](http://www.baeldung.com/java-append-to-file)
+- [Introduction to the Java ArrayDeque](http://www.baeldung.com/java-array-deque)
+- [Guide to java.util.Formatter](http://www.baeldung.com/java-string-formatter)
+- [Batch Processing in JDBC](http://www.baeldung.com/jdbc-batch-processing)

core-java/customers.xml

@@ -0,0 +1,95 @@
+<?xml version="1.0"?>
+<webRowSet xmlns="http://java.sun.com/xml/ns/jdbc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+xsi:schemaLocation="http://java.sun.com/xml/ns/jdbc http://java.sun.com/xml/ns/jdbc/webrowset.xsd">
+  <properties>
+    <command>SELECT * FROM customers</command>
+    <concurrency>1008</concurrency>
+    <datasource><null/></datasource>
+    <escape-processing>true</escape-processing>
+    <fetch-direction>1000</fetch-direction>
+    <fetch-size>0</fetch-size>
+    <isolation-level>2</isolation-level>
+    <key-columns>
+    </key-columns>
+    <map>
+    </map>
+    <max-field-size>0</max-field-size>
+    <max-rows>0</max-rows>
+    <query-timeout>0</query-timeout>
+    <read-only>true</read-only>
+    <rowset-type>ResultSet.TYPE_SCROLL_INSENSITIVE</rowset-type>
+    <show-deleted>false</show-deleted>
+    <table-name>customers</table-name>
+    <url>jdbc:h2:mem:testdb</url>
+    <sync-provider>
+      <sync-provider-name>com.sun.rowset.providers.RIOptimisticProvider</sync-provider-name>
+      <sync-provider-vendor>Oracle Corporation</sync-provider-vendor>
+      <sync-provider-version>1.0</sync-provider-version>
+      <sync-provider-grade>2</sync-provider-grade>
+      <data-source-lock>1</data-source-lock>
+    </sync-provider>
+  </properties>
+  <metadata>
+    <column-count>2</column-count>
+    <column-definition>
+      <column-index>1</column-index>
+      <auto-increment>false</auto-increment>
+      <case-sensitive>true</case-sensitive>
+      <currency>false</currency>
+      <nullable>0</nullable>
+      <signed>true</signed>
+      <searchable>true</searchable>
+      <column-display-size>11</column-display-size>
+      <column-label>ID</column-label>
+      <column-name>ID</column-name>
+      <schema-name>PUBLIC</schema-name>
+      <column-precision>10</column-precision>
+      <column-scale>0</column-scale>
+      <table-name>CUSTOMERS</table-name>
+      <catalog-name>TESTDB</catalog-name>
+      <column-type>4</column-type>
+      <column-type-name>INTEGER</column-type-name>
+    </column-definition>
+    <column-definition>
+      <column-index>2</column-index>
+      <auto-increment>false</auto-increment>
+      <case-sensitive>true</case-sensitive>
+      <currency>false</currency>
+      <nullable>0</nullable>
+      <signed>true</signed>
+      <searchable>true</searchable>
+      <column-display-size>50</column-display-size>
+      <column-label>NAME</column-label>
+      <column-name>NAME</column-name>
+      <schema-name>PUBLIC</schema-name>
+      <column-precision>50</column-precision>
+      <column-scale>0</column-scale>
+      <table-name>CUSTOMERS</table-name>
+      <catalog-name>TESTDB</catalog-name>
+      <column-type>12</column-type>
+      <column-type-name>VARCHAR</column-type-name>
+    </column-definition>
+  </metadata>
+  <data>
+    <currentRow>
+      <columnValue>1</columnValue>
+      <columnValue>Customer1</columnValue>
+    </currentRow>
+    <currentRow>
+      <columnValue>2</columnValue>
+      <columnValue>Customer2</columnValue>
+    </currentRow>
+    <currentRow>
+      <columnValue>3</columnValue>
+      <columnValue>Customer3</columnValue>
+    </currentRow>
+    <currentRow>
+      <columnValue>4</columnValue>
+      <columnValue>Customer4</columnValue>
+    </currentRow>
+    <currentRow>
+      <columnValue>5</columnValue>
+      <columnValue>Customer5</columnValue>
+    </currentRow>
+  </data>
+</webRowSet>

core-java/pom.xml

@@ -181,6 +181,11 @@
             <version>2.1.0.1</version>
         </dependency>
 
+        <dependency>
+            <groupId>com.sun.messaging.mq</groupId>
+            <artifactId>fscontext</artifactId>
+            <version>${fscontext.version}</version>
+        </dependency>
         <dependency>
             <groupId>com.codepoetics</groupId>
             <artifactId>protonpack</artifactId>
@@ -211,6 +216,17 @@
 		    <artifactId>spring-web</artifactId>
 		    <version>4.3.4.RELEASE</version>
 		</dependency>
+ 		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter</artifactId>
+			<version>1.5.8.RELEASE</version>
+		</dependency>
+        <dependency>
+            <groupId>org.hsqldb</groupId>
+            <artifactId>hsqldb</artifactId>
+            <version>2.4.0</version>
+            <scope>runtime</scope>
+        </dependency>
     </dependencies>
 
     <build>
@@ -244,7 +260,7 @@
                         <exclude>**/*LongRunningUnitTest.java</exclude>
                         <exclude>**/*ManualTest.java</exclude>
                     </excludes>
-
+                    <testFailureIgnore>true</testFailureIgnore>
                 </configuration>
             </plugin>
 
@@ -448,7 +464,7 @@
         <logback.version>1.1.7</logback.version>
 
         <!-- util -->
-        <guava.version>23.0</guava.version>
+        <guava.version>22.0</guava.version>
         <commons-lang3.version>3.5</commons-lang3.version>
         <bouncycastle.version>1.55</bouncycastle.version>
         <commons-codec.version>1.10</commons-codec.version>

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

@@ -0,0 +1,21 @@
+package com.baeldung.array;
+
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+public class ArrayBenchmarkRunner {
+
+  public static void main(String[] args) throws Exception {
+
+    Options options = new OptionsBuilder()
+        .include(SearchArrayTest.class.getSimpleName()).threads(1)
+        .forks(1).shouldFailOnError(true).shouldDoGC(true)
+        .jvmArgs("-server").build();
+
+    new Runner(options).run();
+
+
+  }
+
+}

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

@@ -0,0 +1,41 @@
+package com.baeldung.array;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.IntStream;
+
+import org.apache.commons.lang3.ArrayUtils;
+
+import com.google.common.collect.Lists;
+
+public class ArrayInverter {
+
+    public void invertUsingFor(Object[] array) {
+        for (int i = 0; i < array.length / 2; i++) {
+            Object temp = array[i];
+            array[i] = array[array.length - 1 - i];
+            array[array.length - 1 - i] = temp;
+        }
+    }
+
+    public void invertUsingCollectionsReverse(Object[] array) {
+        List<Object> list = Arrays.asList(array);
+        Collections.reverse(list);
+    }
+
+    public Object[] invertUsingStreams(final Object[] array) {
+        return IntStream.range(1, array.length + 1).mapToObj(i -> array[array.length - i]).toArray();
+    }
+
+    public void invertUsingCommonsLang(Object[] array) {
+        ArrayUtils.reverse(array);
+    }
+
+    public Object[] invertUsingGuava(Object[] array) {
+        List<Object> list = Arrays.asList(array);
+        List<Object> reverted = Lists.reverse(list);
+        return reverted.toArray();
+    }
+
+}

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

@@ -0,0 +1,96 @@
+package com.baeldung.array;
+
+import org.openjdk.jmh.annotations.*;
+
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@Warmup(iterations = 5)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+public class SearchArrayTest {
+
+    @State(Scope.Benchmark)
+    public static class SearchData {
+        static int count = 1000;
+        static String[] strings = seedArray(1000);
+    }
+
+
+    @Benchmark
+    public void searchArrayLoop() {
+        for (int i = 0; i < SearchData.count; i++) {
+            searchLoop(SearchData.strings, "T");
+        }
+    }
+
+    @Benchmark
+    public void searchArrayAllocNewList() {
+        for (int i = 0; i < SearchData.count; i++) {
+            searchList(SearchData.strings, "T");
+        }
+
+    }
+
+    @Benchmark
+    public void searchArrayAllocNewSet() {
+        for (int i = 0; i < SearchData.count; i++) {
+            searchSet(SearchData.strings, "T");
+        }
+    }
+
+
+    @Benchmark
+    public void searchArrayReuseList() {
+        List<String> asList = Arrays.asList(SearchData.strings);
+        for (int i = 0; i < SearchData.count; i++) {
+            asList.contains("T");
+        }
+    }
+
+
+    @Benchmark
+    public void searchArrayReuseSet() {
+        Set<String> asSet = new HashSet<>(Arrays.asList(SearchData.strings));
+        for (int i = 0; i < SearchData.count; i++) {
+            asSet.contains("T");
+        }
+    }
+
+
+    @Benchmark
+    public void searchArrayBinarySearch() {
+        Arrays.sort(SearchData.strings);
+        for (int i = 0; i < SearchData.count; i++) {
+            Arrays.binarySearch(SearchData.strings, "T");
+        }
+    }
+
+    private boolean searchList(String[] strings, String searchString) {
+      return Arrays.asList(strings).contains(searchString);
+  }
+
+    private boolean searchSet(String[] strings, String searchString) {
+        Set<String> set = new HashSet<>(Arrays.asList(strings));
+        return set.contains(searchString);
+    }
+
+    private boolean searchLoop(String[] strings, String searchString) {
+        for (String s : strings) {
+            if (s.equals(searchString))
+            return true;
+        }
+        return false;
+    }
+
+    private static String[] seedArray(int length) {
+        String[] strings = new String[length];
+        Random random = new Random();
+        for (int i = 0; i < length; i++)
+        {
+            strings[i] = String.valueOf(random.nextInt());
+        }
+        return strings;
+    }
+
+}

core-java/src/main/java/com/baeldung/interfaces/CommaSeparatedCustomers.java

@@ -0,0 +1,21 @@
+package com.baeldung.interfaces;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class CommaSeparatedCustomers implements Customer.List {
+
+    private List<Customer> customers = new ArrayList<Customer>();
+
+    @Override
+    public void Add(Customer customer) {
+        customers.add(customer);
+    }
+
+    @Override
+    public String getCustomerNames() {
+        return customers.stream().map(customer -> customer.getName()).collect(Collectors.joining(","));
+    }
+
+}

core-java/src/main/java/com/baeldung/interfaces/Customer.java

@@ -0,0 +1,19 @@
+package com.baeldung.interfaces;
+
+public class Customer {
+    public interface List {
+        void Add(Customer customer);
+
+        String getCustomerNames();
+    }
+
+    private String name;
+
+    public Customer(String name) {
+        this.name = name;
+    }
+
+    String getName() {
+        return name;
+    }
+}

core-java/src/main/java/com/baeldung/jdbc/BatchProcessing.java

@@ -0,0 +1,96 @@
+package com.baeldung.jdbc;
+
+import java.sql.*;
+import java.util.UUID;
+
+public class BatchProcessing {
+
+    private final String[] EMPLOYEES = new String[]{"Zuck","Mike","Larry","Musk","Steve"};
+    private final String[] DESIGNATIONS = new String[]{"CFO","CSO","CTO","CEO","CMO"};
+    private final String[] ADDRESSES = new String[]{"China","York","Diego","Carolina","India"};
+
+    private Connection connection;
+
+    public void getConnection(){
+        try {
+            Class.forName("org.hsqldb.jdbcDriver");
+            connection = DriverManager.getConnection("jdbc:hsqldb:file:C:\\EMPLOYEEDB", "SA", "");
+            connection.setAutoCommit(false);
+        } catch (Exception e) {
+            e.printStackTrace(System.out);
+        }
+    }
+
+    public void createTables(){
+        try {
+            connection.createStatement().executeUpdate("create table EMPLOYEE (ID VARCHAR(36), NAME VARCHAR(45), DESIGNATION VARCHAR(15))");
+            connection.createStatement().executeUpdate("create table EMP_ADDRESS (ID VARCHAR(36), EMP_ID VARCHAR(36), ADDRESS VARCHAR(45))");
+            System.out.println("Tables Created!!!");
+        } catch (SQLException e) {
+            e.printStackTrace(System.out);
+        }
+    }
+
+    public void useStatement(){
+        try {
+            String insertEmployeeSQL = "INSERT INTO EMPLOYEE(ID, NAME, DESIGNATION) VALUES ('%s','%s','%s');";
+            String insertEmployeeAddrSQL = "INSERT INTO EMP_ADDRESS(ID, EMP_ID, ADDRESS) VALUES ('%s','%s','%s');";
+            Statement statement = connection.createStatement();
+            for(int i = 0; i < EMPLOYEES.length; i++){
+                String employeeId = UUID.randomUUID().toString();
+                statement.addBatch(String.format(insertEmployeeSQL, employeeId, EMPLOYEES[i],DESIGNATIONS[i]));
+                statement.addBatch(String.format(insertEmployeeAddrSQL, UUID.randomUUID().toString(),employeeId,ADDRESSES[i]));
+            }
+            statement.executeBatch();
+            connection.commit();
+        } catch (Exception e) {
+            try {
+                connection.rollback();
+            } catch (SQLException ex) {
+                System.out.println("Error during rollback");
+                System.out.println(ex.getMessage());
+            }
+            e.printStackTrace(System.out);
+        }
+    }
+
+    public void usePreparedStatement(){
+        try {
+            String insertEmployeeSQL = "INSERT INTO EMPLOYEE(ID, NAME, DESIGNATION) VALUES (?,?,?);";
+            String insertEmployeeAddrSQL = "INSERT INTO EMP_ADDRESS(ID, EMP_ID, ADDRESS) VALUES (?,?,?);";
+            PreparedStatement employeeStmt = connection.prepareStatement(insertEmployeeSQL);
+            PreparedStatement empAddressStmt = connection.prepareStatement(insertEmployeeAddrSQL);
+            for(int i = 0; i < EMPLOYEES.length; i++){
+                String employeeId = UUID.randomUUID().toString();
+                employeeStmt.setString(1,employeeId);
+                employeeStmt.setString(2,EMPLOYEES[i]);
+                employeeStmt.setString(3,DESIGNATIONS[i]);
+                employeeStmt.addBatch();
+
+                empAddressStmt.setString(1,UUID.randomUUID().toString());
+                empAddressStmt.setString(2,employeeId);
+                empAddressStmt.setString(3,ADDRESSES[i]);
+                empAddressStmt.addBatch();
+            }
+            employeeStmt.executeBatch();
+            empAddressStmt.executeBatch();
+            connection.commit();
+        } catch (Exception e) {
+            try {
+                connection.rollback();
+            } catch (SQLException ex) {
+                System.out.println("Error during rollback");
+                System.out.println(ex.getMessage());
+            }
+            e.printStackTrace(System.out);
+        }
+    }
+
+    public static void main(String[] args) {
+        BatchProcessing batchProcessing = new BatchProcessing();
+        batchProcessing.getConnection();
+        batchProcessing.createTables();
+        batchProcessing.useStatement();
+        batchProcessing.usePreparedStatement();
+    }
+}

core-java/src/main/java/com/baeldung/jdbcrowset/DatabaseConfiguration.java

@@ -0,0 +1,51 @@
+package com.baeldung.jdbcrowset;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import javax.sql.rowset.JdbcRowSet;
+import javax.sql.rowset.RowSetFactory;
+import javax.sql.rowset.RowSetProvider;
+
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@EnableAutoConfiguration
+public class DatabaseConfiguration {
+ 
+    
+    public static Connection geth2Connection() throws Exception {
+        Class.forName("org.h2.Driver");
+        System.out.println("Driver Loaded.");
+        String url = "jdbc:h2:mem:testdb";
+        return DriverManager.getConnection(url, "sa", "");
+      }
+    
+    public static void initDatabase(Statement stmt) throws SQLException{
+        int iter = 1;
+        while(iter<=5){
+            String customer = "Customer"+iter;
+            String sql ="INSERT INTO customers(id, name) VALUES ("+iter+ ",'"+customer+"');";
+            System.out.println("here is sql statmeent for execution: " + sql);
+            stmt.executeUpdate(sql);
+            iter++;
+        }
+        
+        int iterb = 1;
+        while(iterb<=5){
+            String associate = "Associate"+iter;
+            String sql = "INSERT INTO associates(id, name) VALUES("+iterb+",'"+associate+"');";
+            System.out.println("here is sql statement for associate:"+ sql);
+            stmt.executeUpdate(sql);
+            iterb++;
+        }
+        
+        
+    }
+    
+    
+
+}

core-java/src/main/java/com/baeldung/jdbcrowset/ExampleListener.java

@@ -0,0 +1,24 @@
+package com.baeldung.jdbcrowset;
+
+import javax.sql.RowSetEvent;
+import javax.sql.RowSetListener;
+
+public class ExampleListener implements RowSetListener {
+    
+
+    public void cursorMoved(RowSetEvent event) {
+      System.out.println("ExampleListener alerted of cursorMoved event");
+      System.out.println(event.toString());
+    }
+
+    public void rowChanged(RowSetEvent event) {
+      System.out.println("ExampleListener alerted of rowChanged event");
+      System.out.println(event.toString());
+    }
+
+    public void rowSetChanged(RowSetEvent event) {
+      System.out.println("ExampleListener alerted of rowSetChanged event");
+      System.out.println(event.toString());
+    }
+
+}

core-java/src/main/java/com/baeldung/jdbcrowset/FilterExample.java

@@ -0,0 +1,46 @@
+package com.baeldung.jdbcrowset;
+
+import java.sql.SQLException;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import javax.sql.RowSet;
+import javax.sql.rowset.Predicate;
+
+public class FilterExample implements Predicate {
+    
+    private Pattern pattern;
+    
+    public FilterExample(String regexQuery) {
+        if (regexQuery != null && !regexQuery.isEmpty()) {
+            pattern = Pattern.compile(regexQuery);
+        }
+    }
+ 
+    public boolean evaluate(RowSet rs) {
+        try {
+            if (!rs.isAfterLast()) {
+                String name = rs.getString("name");
+                System.out.println(String.format(
+                        "Searching for pattern '%s' in %s", pattern.toString(),
+                        name));
+                Matcher matcher = pattern.matcher(name);
+                return matcher.matches();
+            } else
+                return false;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+ 
+    public boolean evaluate(Object value, int column) throws SQLException {
+        throw new UnsupportedOperationException("This operation is unsupported.");
+    }
+ 
+    public boolean evaluate(Object value, String columnName)
+            throws SQLException {
+        throw new UnsupportedOperationException("This operation is unsupported.");
+    }
+
+}

core-java/src/main/java/com/baeldung/jdbcrowset/JdbcRowsetApplication.java

@@ -0,0 +1,139 @@
+package com.baeldung.jdbcrowset;
+
+import java.io.FileOutputStream;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import com.sun.rowset.*;
+
+import javax.sql.rowset.CachedRowSet;
+import javax.sql.rowset.FilteredRowSet;
+import javax.sql.rowset.JdbcRowSet;
+import javax.sql.rowset.JoinRowSet;
+import javax.sql.rowset.RowSetFactory;
+import javax.sql.rowset.RowSetProvider;
+import javax.sql.rowset.WebRowSet;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class JdbcRowsetApplication {
+
+    public static void main(String[] args) throws Exception {
+        SpringApplication.run(JdbcRowsetApplication.class, args);
+        Statement stmt = null;
+        try {
+            Connection conn = DatabaseConfiguration.geth2Connection();
+
+            String drop = "DROP TABLE IF EXISTS customers, associates;";
+            String schema = "CREATE TABLE customers (id INT NOT NULL, name VARCHAR(50) NOT NULL, PRIMARY KEY (id)); ";
+            String schemapartb = "CREATE TABLE associates (id INT NOT NULL, name VARCHAR(50) NOT NULL, PRIMARY KEY (id));";
+
+            stmt = conn.createStatement();
+            stmt.executeUpdate(drop);
+            stmt.executeUpdate(schema);
+            stmt.executeUpdate(schemapartb);
+            // insert data
+            DatabaseConfiguration.initDatabase(stmt);
+            // JdbcRowSet Example
+            String sql = "SELECT * FROM customers";
+            JdbcRowSet jdbcRS;
+            jdbcRS = new JdbcRowSetImpl(conn);
+            jdbcRS.setType(ResultSet.TYPE_SCROLL_INSENSITIVE);
+            jdbcRS.setCommand(sql);
+            jdbcRS.execute();
+            jdbcRS.addRowSetListener(new ExampleListener());
+
+            while (jdbcRS.next()) {
+                // each call to next, generates a cursorMoved event
+                System.out.println("id=" + jdbcRS.getString(1));
+                System.out.println("name=" + jdbcRS.getString(2));
+            }
+
+            // CachedRowSet Example
+            String username = "sa";
+            String password = "";
+            String url = "jdbc:h2:mem:testdb";
+            CachedRowSet crs = new CachedRowSetImpl();
+            crs.setUsername(username);
+            crs.setPassword(password);
+            crs.setUrl(url);
+            crs.setCommand(sql);
+            crs.execute();
+            crs.addRowSetListener(new ExampleListener());
+            while (crs.next()) {
+                if (crs.getInt("id") == 1) {
+                    System.out.println("CRS found customer1 and will remove the record.");
+                    crs.deleteRow();
+                    break;
+                }
+            }
+
+            // WebRowSet example
+            WebRowSet wrs = new WebRowSetImpl();
+            wrs.setUsername(username);
+            wrs.setPassword(password);
+            wrs.setUrl(url);
+            wrs.setCommand(sql);
+            wrs.execute();
+            FileOutputStream ostream = new FileOutputStream("customers.xml");
+            wrs.writeXml(ostream);
+
+            // JoinRowSet example
+            CachedRowSetImpl customers = new CachedRowSetImpl();
+            customers.setUsername(username);
+            customers.setPassword(password);
+            customers.setUrl(url);
+            customers.setCommand(sql);
+            customers.execute();
+
+            CachedRowSetImpl associates = new CachedRowSetImpl();
+            associates.setUsername(username);
+            associates.setPassword(password);
+            associates.setUrl(url);
+            String associatesSQL = "SELECT * FROM associates";
+            associates.setCommand(associatesSQL);
+            associates.execute();
+
+            JoinRowSet jrs = new JoinRowSetImpl();
+            final String ID = "id";
+            final String NAME = "name";
+            jrs.addRowSet(customers, ID);
+            jrs.addRowSet(associates, ID);
+            jrs.last();
+            System.out.println("Total rows: " + jrs.getRow());
+            jrs.beforeFirst();
+            while (jrs.next()) {
+
+                String string1 = jrs.getString(ID);
+                String string2 = jrs.getString(NAME);
+                System.out.println("ID: " + string1 + ", NAME: " + string2);
+            }
+
+            // FilteredRowSet example
+            RowSetFactory rsf = RowSetProvider.newFactory();
+            FilteredRowSet frs = rsf.createFilteredRowSet();
+            frs.setCommand("select * from customers");
+            frs.execute(conn);
+            frs.setFilter(new FilterExample("^[A-C].*"));
+
+            ResultSetMetaData rsmd = frs.getMetaData();
+            int columncount = rsmd.getColumnCount();
+            while (frs.next()) {
+                for (int i = 1; i <= columncount; i++) {
+                    System.out.println(rsmd.getColumnLabel(i) + " = " + frs.getObject(i) + " ");
+                }
+            }
+
+        } catch (SQLException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }
+
+    }
+
+}

core-java/src/main/java/com/baeldung/nestedclass/Enclosing.java

@@ -1,11 +0,0 @@
-package com.baeldung.nestedclass;
-
-public class Enclosing {
-
-    public static class Nested {
-
-        public void test() {
-            System.out.println("Calling test...");
-        }
-    }
-}

core-java/src/main/java/com/baeldung/nestedclass/Outer.java

@@ -1,11 +0,0 @@
-package com.baeldung.nestedclass;
-
-public class Outer {
-
-    public class Inner {
-
-        public void test() {
-            System.out.println("Calling test...");
-        }
-    }
-}

core-java/src/main/java/com/baeldung/nestedclass/SimpleAbstractClass.java

@@ -1,5 +0,0 @@
-package com.baeldung.nestedclass;
-
-abstract class SimpleAbstractClass {
-    abstract void run();
-}

core-java/src/main/java/com/baeldung/polymorphism/FileManager.java

@@ -0,0 +1,38 @@
+package com.baeldung.polymorphism;
+
+import java.awt.image.BufferedImage;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class FileManager {
+
+    final static Logger logger = LoggerFactory.getLogger(FileManager.class);
+
+    public static void main(String[] args) {
+        GenericFile file1 = new TextFile("SampleTextFile", "This is a sample text content", "v1.0.0");
+        logger.info("File Info: \n" + file1.getFileInfo() + "\n");
+        ImageFile imageFile = new ImageFile("SampleImageFile", 200, 100, new BufferedImage(100, 200, BufferedImage.TYPE_INT_RGB).toString()
+            .getBytes(), "v1.0.0");
+        logger.info("File Info: \n" + imageFile.getFileInfo());
+    }
+
+    public static ImageFile createImageFile(String name, int height, int width, byte[] content, String version) {
+        ImageFile imageFile = new ImageFile(name, height, width, content, version);
+        logger.info("File 2 Info: \n" + imageFile.getFileInfo());
+        return imageFile;
+    }
+
+    public static GenericFile createTextFile(String name, String content, String version) {
+        GenericFile file1 = new TextFile(name, content, version);
+        logger.info("File 1 Info: \n" + file1.getFileInfo() + "\n");
+        return file1;
+    }
+    
+    public static TextFile createTextFile2(String name, String content, String version) {
+        TextFile file1 = new TextFile(name, content, version);
+        logger.info("File 1 Info: \n" + file1.getFileInfo() + "\n");
+        return file1;
+    }
+
+}

core-java/src/main/java/com/baeldung/polymorphism/GenericFile.java

@@ -0,0 +1,63 @@
+package com.baeldung.polymorphism;
+
+import java.util.Date;
+
+public class GenericFile {
+    private String name;
+    private String extension;
+    private Date dateCreated;
+    private String version;
+    private byte[] content;
+
+    public GenericFile() {
+        this.setDateCreated(new Date());
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getExtension() {
+        return extension;
+    }
+
+    public void setExtension(String extension) {
+        this.extension = extension;
+    }
+
+    public Date getDateCreated() {
+        return dateCreated;
+    }
+
+    public void setDateCreated(Date dateCreated) {
+        this.dateCreated = dateCreated;
+    }
+
+    public String getVersion() {
+        return version;
+    }
+
+    public void setVersion(String version) {
+        this.version = version;
+    }
+
+    public byte[] getContent() {
+        return content;
+    }
+
+    public void setContent(byte[] content) {
+        this.content = content;
+    }
+
+    public String getFileInfo() {
+        return "Generic File Impl";
+    }
+
+    public Object read() {
+        return content;
+    }
+}

core-java/src/main/java/com/baeldung/polymorphism/ImageFile.java

@@ -0,0 +1,41 @@
+package com.baeldung.polymorphism;
+
+public class ImageFile extends GenericFile {
+    private int height;
+    private int width;
+
+    public ImageFile(String name, int height, int width, byte[] content, String version) {
+        this.setHeight(height);
+        this.setWidth(width);
+        this.setContent(content);
+        this.setName(name);
+        this.setVersion(version);
+        this.setExtension(".jpg");
+    }
+
+    public int getHeight() {
+        return height;
+    }
+
+    public void setHeight(int height) {
+        this.height = height;
+    }
+
+    public int getWidth() {
+        return width;
+    }
+
+    public void setWidth(int width) {
+        this.width = width;
+    }
+
+    public String getFileInfo() {
+        return "Image File Impl";
+    }
+
+    public String read() {
+        return this.getContent()
+            .toString();
+    }
+
+}

core-java/src/main/java/com/baeldung/polymorphism/TextFile.java

@@ -0,0 +1,44 @@
+package com.baeldung.polymorphism;
+
+public class TextFile extends GenericFile {
+    private int wordCount;
+
+    public TextFile(String name, String content, String version) {
+        String[] words = content.split(" ");
+        this.setWordCount(words.length > 0 ? words.length : 1);
+        this.setContent(content.getBytes());
+        this.setName(name);
+        this.setVersion(version);
+        this.setExtension(".txt");
+    }
+
+    public int getWordCount() {
+        return wordCount;
+    }
+
+    public void setWordCount(int wordCount) {
+        this.wordCount = wordCount;
+    }
+
+    public String getFileInfo() {
+        return "Text File Impl";
+    }
+
+    public String read() {
+        return this.getContent()
+            .toString();
+    }
+
+    public String read(int limit) {
+        return this.getContent()
+            .toString()
+            .substring(0, limit);
+    }
+
+    public String read(int start, int stop) {
+        return this.getContent()
+            .toString()
+            .substring(start, stop);
+    }
+
+}

core-java/src/main/java/com/baeldung/stream/FileCopy.java

@@ -0,0 +1,48 @@
+package com.baeldung.stream;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+
+import org.apache.commons.io.FileUtils;
+
+public class FileCopy {
+
+    public static void copyFileUsingStream(File source, File dest) throws IOException {
+        InputStream is = null;
+        OutputStream os = null;
+        is = new FileInputStream(source);
+        os = new FileOutputStream(dest);
+        byte[] buffer = new byte[1024];
+        int length;
+        while ((length = is.read(buffer)) > 0) {
+            os.write(buffer, 0, length);
+        }
+        is.close();
+        os.close();
+    }
+
+    public static void copyFileUsingChannel(File source, File dest) throws IOException {
+        FileChannel sourceChannel = null;
+        FileChannel destChannel = null;
+        sourceChannel = new FileInputStream(source).getChannel();
+        destChannel = new FileOutputStream(dest).getChannel();
+        destChannel.transferFrom(sourceChannel, 0, sourceChannel.size());
+        sourceChannel.close();
+        destChannel.close();
+    }
+
+    public static void copyFileUsingApacheCommonsIO(File source, File dest) throws IOException {
+        FileUtils.copyFile(source, dest);
+    }
+
+    public static void copyFileUsingJavaFiles(File source, File dest) throws IOException {
+        Files.copy(source.toPath(), dest.toPath());
+    }
+
+}

core-java/src/main/java/com/baeldung/tree/BinaryTree.java

@@ -0,0 +1,164 @@
+package com.baeldung.tree;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class BinaryTree {
+
+    Node root;
+
+    public void add(int value) {
+
+        Node newNode = new Node(value);
+
+        if (root == null) {
+            root = newNode;
+            return;
+        }
+
+        addRecursive(root, value);
+    }
+
+    private Node addRecursive(Node current, int value) {
+
+        if (current == null) {
+            return new Node(value);
+        }
+
+        if (value < current.value) {
+            current.left = addRecursive(current.left, value);
+        } else {
+            current.right = addRecursive(current.right, value);
+        }
+
+        return current;
+
+    }
+
+    public boolean isEmpty() {
+        return root == null;
+    }
+
+    public boolean containsNode(int value) {
+        return containsNodeRecursive(root, value);
+    }
+
+    private boolean containsNodeRecursive(Node current, int value) {
+
+        if (current == null) {
+            return false;
+        } else if (value == current.value) {
+            return true;
+        } else if (value < current.value) {
+            return containsNodeRecursive(current.left, value);
+        } else {
+            return containsNodeRecursive(current.right, value);
+        }
+
+    }
+
+    public void delete(int value) {
+        deleteRecursive(root, value);
+    }
+
+    private Node deleteRecursive(Node current, int value) {
+        if (current == null) {
+            return null;
+        }
+
+        if (value == current.value) {
+            // Case 1: no children
+            if (current.left == null && current.right == null) {
+                return null;
+            }
+
+            // Case 2: only 1 child
+            if (current.right == null) {
+                return current.left;
+            }
+
+            if (current.left == null) {
+                return current.right;
+            }
+
+            // Case 3: 2 children
+            int smallestValue = findSmallestValue(current.right);
+            current.value = smallestValue;
+            current.right = deleteRecursive(current.right, smallestValue);
+            return current;
+
+        } else if (value < current.value) {
+            current.left = deleteRecursive(current.left, value);
+            return current;
+        } else {
+            current.right = deleteRecursive(current.right, value);
+            return current;
+        }
+    }
+
+    private int findSmallestValue(Node root) {
+
+        if (root.left == null) {
+            return root.value;
+        }
+
+        return findSmallestValue(root.left);
+    }
+
+    public void traverseInOrder(Node node) {
+        if (node != null) {
+            traverseInOrder(node.left);
+            System.out.print(" " + node.value);
+            traverseInOrder(node.right);
+        }
+    }
+
+    public void traversePreOrder(Node node) {
+        if (node != null) {
+            System.out.print(" " + node.value);
+            traversePreOrder(node.left);
+            traversePreOrder(node.right);
+        }
+    }
+
+    public void traversePostOrder(Node node) {
+        if (node != null) {
+            traversePostOrder(node.left);
+            traversePostOrder(node.right);
+
+            System.out.print(" " + node.value);
+        }
+    }
+
+    public void traverseLevelOrder() {
+        Queue<Node> nodes = new LinkedList<>();
+        nodes.add(root);
+
+        while (!nodes.isEmpty()) {
+
+            Node node = nodes.remove();
+
+            System.out.print(" " + node.value);
+
+            if (node.left != null) {
+                nodes.add(node.left);
+            }
+
+            if (node.left != null) {
+                nodes.add(node.right);
+            }
+        }
+    }
+
+    class Node {
+        int value;
+        Node left;
+        Node right;
+
+        Node(int value) {
+            this.value = value;
+            right = null;
+            left = null;
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+package com.baeldung.array;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+public class ArrayInverterUnitTest {
+
+    private String[] fruits = { "apples", "tomatoes", "bananas", "guavas", "pineapples", "oranges" };
+
+    @Test
+    public void invertArrayWithForLoop() {
+        ArrayInverter inverter = new ArrayInverter();
+        inverter.invertUsingFor(fruits);
+
+        assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(fruits);
+    }
+
+    @Test
+    public void invertArrayWithCollectionsReverse() {
+        ArrayInverter inverter = new ArrayInverter();
+        inverter.invertUsingCollectionsReverse(fruits);
+
+        assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(fruits);
+    }
+
+    @Test
+    public void invertArrayWithStreams() {
+        ArrayInverter inverter = new ArrayInverter();
+
+        assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(inverter.invertUsingStreams(fruits));
+    }
+
+    @Test
+    public void invertArrayWithCommonsLang() {
+        ArrayInverter inverter = new ArrayInverter();
+        inverter.invertUsingCommonsLang(fruits);
+
+        assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(fruits);
+    }
+
+    @Test
+    public void invertArrayWithGuava() {
+        ArrayInverter inverter = new ArrayInverter();
+
+        assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(inverter.invertUsingGuava(fruits));
+    }
+
+}

core-java/src/test/java/com/baeldung/collection/WhenUsingHashSet.java

@@ -0,0 +1,93 @@
+package com.baeldung.collection;
+
+import java.util.ConcurrentModificationException;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class WhenUsingHashSet {
+
+    @Test
+    public void whenAddingElement_shouldAddElement() {
+        Set<String> hashset = new HashSet<>();
+        Assert.assertTrue(hashset.add("String Added"));
+    }
+
+    @Test
+    public void whenCheckingForElement_shouldSearchForElement() {
+        Set<String> hashsetContains = new HashSet<>();
+        hashsetContains.add("String Added");
+        Assert.assertTrue(hashsetContains.contains("String Added"));
+    }
+
+    @Test
+    public void whenCheckingTheSizeOfHashSet_shouldReturnThesize() {
+        Set<String> hashSetSize = new HashSet<>();
+        hashSetSize.add("String Added");
+        Assert.assertEquals(1, hashSetSize.size());
+    }
+
+    @Test
+    public void whenCheckingForEmptyHashSet_shouldCheckForEmpty() {
+        Set<String> emptyHashSet = new HashSet<>();
+        Assert.assertTrue(emptyHashSet.isEmpty());
+    }
+
+    @Test
+    public void whenRemovingElement_shouldRemoveElement() {
+        Set<String> removeFromHashSet = new HashSet<>();
+        removeFromHashSet.add("String Added");
+        Assert.assertTrue(removeFromHashSet.remove("String Added"));
+    }
+
+    @Test
+    public void whenClearingHashSet_shouldClearHashSet() {
+        Set<String> clearHashSet = new HashSet<>();
+        clearHashSet.add("String Added");
+        clearHashSet.clear();
+        Assert.assertTrue(clearHashSet.isEmpty());
+    }
+
+    @Test
+    public void whenIteratingHashSet_shouldIterateHashSet() {
+        Set<String> hashset = new HashSet<>();
+        hashset.add("First");
+        hashset.add("Second");
+        hashset.add("Third");
+        Iterator<String> itr = hashset.iterator();
+        while (itr.hasNext()) {
+            System.out.println(itr.next());
+        }
+    }
+
+    @Test(expected = ConcurrentModificationException.class)
+    public void whenModifyingHashSetWhileIterating_shouldThrowException() {
+        Set<String> hashset = new HashSet<>();
+        hashset.add("First");
+        hashset.add("Second");
+        hashset.add("Third");
+        Iterator<String> itr = hashset.iterator();
+        while (itr.hasNext()) {
+            itr.next();
+            hashset.remove("Second");
+        }
+    }
+
+    @Test
+    public void whenRemovingElementUsingIterator_shouldRemoveElement() {
+        Set<String> hashset = new HashSet<>();
+        hashset.add("First");
+        hashset.add("Second");
+        hashset.add("Third");
+        Iterator<String> itr = hashset.iterator();
+        while (itr.hasNext()) {
+            String element = itr.next();
+            if (element.equals("Second"))
+                itr.remove();
+        }
+        Assert.assertEquals(2, hashset.size());
+    }
+}

core-java/src/test/java/com/baeldung/collection/WhenUsingTreeSet.java

@@ -0,0 +1,228 @@
+package com.baeldung.collection;
+
+import java.util.Comparator;
+import java.util.ConcurrentModificationException;
+import java.util.Iterator;
+import java.util.NavigableSet;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class WhenUsingTreeSet {
+
+    private static class Element {
+        private Integer id;
+
+        public Integer getId() {
+            return id;
+        }
+
+        public void setId(Integer id) {
+            this.id = id;
+        }
+
+        @Override
+        public String toString() {
+            return id.toString();
+        }
+    }
+
+    private Comparator<Element> comparator = (ele1, ele2) -> {
+        return ele1.getId()
+            .compareTo(ele2.getId());
+    };
+
+    @Test
+    public void whenAddingElement_shouldAddElement() {
+        Set<String> treeSet = new TreeSet<>();
+        Assert.assertTrue(treeSet.add("String Added"));
+    }
+
+    @Test
+    public void whenCheckingForElement_shouldSearchForElement() {
+        Set<String> treeSetContains = new TreeSet<>();
+        treeSetContains.add("String Added");
+        Assert.assertTrue(treeSetContains.contains("String Added"));
+    }
+
+    @Test
+    public void whenRemovingElement_shouldRemoveElement() {
+        Set<String> removeFromTreeSet = new TreeSet<>();
+        removeFromTreeSet.add("String Added");
+        Assert.assertTrue(removeFromTreeSet.remove("String Added"));
+    }
+
+    @Test
+    public void whenClearingTreeSet_shouldClearTreeSet() {
+        Set<String> clearTreeSet = new TreeSet<>();
+        clearTreeSet.add("String Added");
+        clearTreeSet.clear();
+        Assert.assertTrue(clearTreeSet.isEmpty());
+    }
+
+    @Test
+    public void whenCheckingTheSizeOfTreeSet_shouldReturnThesize() {
+        Set<String> treeSetSize = new TreeSet<>();
+        treeSetSize.add("String Added");
+        Assert.assertEquals(1, treeSetSize.size());
+    }
+
+    @Test
+    public void whenCheckingForEmptyTreeSet_shouldCheckForEmpty() {
+        Set<String> emptyTreeSet = new TreeSet<>();
+        Assert.assertTrue(emptyTreeSet.isEmpty());
+    }
+
+    @Test
+    public void whenIteratingTreeSet_shouldIterateTreeSetInAscendingOrder() {
+        Set<String> treeSet = new TreeSet<>();
+        treeSet.add("First");
+        treeSet.add("Second");
+        treeSet.add("Third");
+        Iterator<String> itr = treeSet.iterator();
+        while (itr.hasNext()) {
+            System.out.println(itr.next());
+        }
+    }
+
+    @Test
+    public void whenIteratingTreeSet_shouldIterateTreeSetInDescendingOrder() {
+        TreeSet<String> treeSet = new TreeSet<>();
+        treeSet.add("First");
+        treeSet.add("Second");
+        treeSet.add("Third");
+        Iterator<String> itr = treeSet.descendingIterator();
+        while (itr.hasNext()) {
+            System.out.println(itr.next());
+        }
+    }
+
+    @Test(expected = ConcurrentModificationException.class)
+    public void whenModifyingTreeSetWhileIterating_shouldThrowException() {
+        Set<String> treeSet = new TreeSet<>();
+        treeSet.add("First");
+        treeSet.add("Second");
+        treeSet.add("Third");
+        Iterator<String> itr = treeSet.iterator();
+        while (itr.hasNext()) {
+            itr.next();
+            treeSet.remove("Second");
+        }
+    }
+
+    @Test
+    public void whenRemovingElementUsingIterator_shouldRemoveElement() {
+        Set<String> treeSet = new TreeSet<>();
+        treeSet.add("First");
+        treeSet.add("Second");
+        treeSet.add("Third");
+        Iterator<String> itr = treeSet.iterator();
+        while (itr.hasNext()) {
+            String element = itr.next();
+            if (element.equals("Second"))
+                itr.remove();
+        }
+        Assert.assertEquals(2, treeSet.size());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void whenAddingNullToNonEmptyTreeSet_shouldThrowException() {
+        Set<String> treeSet = new TreeSet<>();
+        treeSet.add("First");
+        treeSet.add(null);
+    }
+
+    @Test
+    public void whenCheckingFirstElement_shouldReturnFirstElement() {
+        TreeSet<String> treeSet = new TreeSet<>();
+        treeSet.add("First");
+        Assert.assertEquals("First", treeSet.first());
+    }
+
+    @Test
+    public void whenCheckingLastElement_shouldReturnLastElement() {
+        TreeSet<String> treeSet = new TreeSet<>();
+        treeSet.add("First");
+        treeSet.add("Last");
+        Assert.assertEquals("Last", treeSet.last());
+    }
+
+    @Test
+    public void whenUsingComparator_shouldSortAndInsertElements() {
+        Set<Element> treeSet = new TreeSet<>(comparator);
+        Element ele1 = new Element();
+        ele1.setId(100);
+        Element ele2 = new Element();
+        ele2.setId(200);
+
+        treeSet.add(ele1);
+        treeSet.add(ele2);
+
+        System.out.println(treeSet);
+    }
+
+    @Test
+    public void whenUsingHeadSet_shouldReturnElementsLessThanSpecifiedElement() {
+        Set<Element> treeSet = new TreeSet<>(comparator);
+        Element ele1 = new Element();
+        ele1.setId(100);
+        Element ele2 = new Element();
+        ele2.setId(200);
+
+        treeSet.add(ele1);
+        treeSet.add(ele2);
+
+        System.out.println(treeSet);
+    }
+
+    @Test
+    public void whenUsingSubSet_shouldReturnSubSetElements() {
+        SortedSet<Integer> treeSet = new TreeSet<>();
+        treeSet.add(1);
+        treeSet.add(2);
+        treeSet.add(3);
+        treeSet.add(4);
+        treeSet.add(5);
+        treeSet.add(6);
+
+        Set<Integer> expectedSet = new TreeSet<>();
+        expectedSet.add(2);
+        expectedSet.add(3);
+        expectedSet.add(4);
+        expectedSet.add(5);
+
+        Set<Integer> subSet = treeSet.subSet(2, 6);
+        Assert.assertEquals(expectedSet, subSet);
+    }
+
+    @Test
+    public void whenUsingHeadSet_shouldReturnHeadSetElements() {
+        SortedSet<Integer> treeSet = new TreeSet<>();
+        treeSet.add(1);
+        treeSet.add(2);
+        treeSet.add(3);
+        treeSet.add(4);
+        treeSet.add(5);
+        treeSet.add(6);
+
+        Set<Integer> subSet = treeSet.headSet(6);
+        Assert.assertEquals(subSet, treeSet.subSet(1, 6));
+    }
+
+    @Test
+    public void whenUsingTailSet_shouldReturnTailSetElements() {
+        NavigableSet<Integer> treeSet = new TreeSet<>();
+        treeSet.add(1);
+        treeSet.add(2);
+        treeSet.add(3);
+        treeSet.add(4);
+        treeSet.add(5);
+        treeSet.add(6);
+
+        Set<Integer> subSet = treeSet.tailSet(3);
+        Assert.assertEquals(subSet, treeSet.subSet(3, true, 6, true));
+    }
+}

core-java/src/test/java/com/baeldung/interfaces/InnerInterfaceTests.java

@@ -0,0 +1,18 @@
+package com.baeldung.interfaces;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class InnerInterfaceTests {
+    @Test
+    public void whenCustomerListJoined_thenReturnsJoinedNames() {
+        Customer.List customerList = new CommaSeparatedCustomers();
+        customerList.Add(new Customer("customer1"));
+        customerList.Add(new Customer("customer2"));
+        assertEquals("customer1,customer2", customerList.getCustomerNames());
+    }
+}

core-java/src/test/java/com/baeldung/jdbc/BatchProcessingTest.java

@@ -0,0 +1,71 @@
+package com.baeldung.jdbc;
+
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.Statement;
+
+@RunWith(MockitoJUnitRunner.class)
+public class BatchProcessingTest {
+
+
+    @InjectMocks
+    private BatchProcessing target = new BatchProcessing();
+
+    @Mock
+    private Connection connection;
+
+    @Mock
+    private Statement statement;
+
+    @Mock
+    private PreparedStatement employeeStatement;
+
+    @Mock
+    private PreparedStatement employeeAddressStatement;
+
+    @Before
+    public void before(){
+        MockitoAnnotations.initMocks(this);
+    }
+
+
+    @Test
+    public void when_useStatement_thenInsertData_success() throws Exception {
+        Mockito.when(connection.createStatement()).thenReturn(statement);
+        target.useStatement();
+    }
+
+    @Test
+    public void when_useStatement_ifThrowException_thenCatchException() throws Exception {
+        Mockito.when(connection.createStatement()).thenThrow(new RuntimeException());
+        target.useStatement();
+    }
+
+    @Test
+    public void when_usePreparedStatement_thenInsertData_success() throws Exception {
+        String insertEmployeeSQL = "INSERT INTO EMPLOYEE(ID, NAME, DESIGNATION) VALUES (?,?,?);";
+        String insertEmployeeAddrSQL = "INSERT INTO EMP_ADDRESS(ID, EMP_ID, ADDRESS) VALUES (?,?,?);";
+        Mockito.when(connection.prepareStatement(insertEmployeeSQL)).thenReturn(employeeStatement);
+        Mockito.when(connection.prepareStatement(insertEmployeeAddrSQL)).thenReturn(employeeAddressStatement);
+        target.usePreparedStatement();
+    }
+
+    @Test
+    public void when_usePreparedStatement_ifThrowException_thenCatchException() throws Exception {
+        String insertEmployeeSQL = "INSERT INTO EMPLOYEE(ID, NAME, DESIGNATION) VALUES (?,?,?);";
+        String insertEmployeeAddrSQL = "INSERT INTO EMP_ADDRESS(ID, EMP_ID, ADDRESS) VALUES (?,?,?);";
+        Mockito.when(connection.prepareStatement(insertEmployeeSQL)).thenReturn(employeeStatement);
+        Mockito.when(connection.prepareStatement(insertEmployeeAddrSQL)).thenThrow(new RuntimeException());
+        target.usePreparedStatement();
+    }
+}

core-java/src/test/java/com/baeldung/jdbcrowset/JdbcRowSetTest.java

@@ -0,0 +1,157 @@
+package com.baeldung.jdbcrowset;
+
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import javax.sql.rowset.CachedRowSet;
+import javax.sql.rowset.FilteredRowSet;
+import javax.sql.rowset.JdbcRowSet;
+import javax.sql.rowset.JoinRowSet;
+import javax.sql.rowset.RowSetFactory;
+import javax.sql.rowset.RowSetProvider;
+import javax.sql.rowset.WebRowSet;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.sun.rowset.CachedRowSetImpl;
+import com.sun.rowset.JdbcRowSetImpl;
+import com.sun.rowset.JoinRowSetImpl;
+import com.sun.rowset.WebRowSetImpl;
+
+public class JdbcRowSetTest {
+    Statement stmt = null;
+    String username = "sa";
+    String password = "";
+    String url = "jdbc:h2:mem:testdb";
+    String sql = "SELECT * FROM customers";
+
+    @Before
+    public void setup() throws Exception {
+        Connection conn = DatabaseConfiguration.geth2Connection();
+
+        String drop = "DROP TABLE IF EXISTS customers, associates;";
+        String schema = "CREATE TABLE customers (id INT NOT NULL, name VARCHAR(50) NOT NULL, PRIMARY KEY (id)); ";
+        String schemapartb = "CREATE TABLE associates (id INT NOT NULL, name VARCHAR(50) NOT NULL, PRIMARY KEY (id));";
+        stmt = conn.createStatement();
+        stmt.executeUpdate(drop);
+        stmt.executeUpdate(schema);
+        stmt.executeUpdate(schemapartb);
+        DatabaseConfiguration.initDatabase(stmt);
+
+    }
+
+    // JdbcRowSet Example
+    @Test
+    public void createJdbcRowSet_SelectCustomers_ThenCorrect() throws Exception {
+
+        String sql = "SELECT * FROM customers";
+        JdbcRowSet jdbcRS;
+        Connection conn = DatabaseConfiguration.geth2Connection();
+        jdbcRS = new JdbcRowSetImpl(conn);
+        jdbcRS.setType(ResultSet.TYPE_SCROLL_INSENSITIVE);
+        jdbcRS.setCommand(sql);
+        jdbcRS.execute();
+        jdbcRS.addRowSetListener(new ExampleListener());
+
+        while (jdbcRS.next()) {
+            // each call to next, generates a cursorMoved event
+            System.out.println("id=" + jdbcRS.getString(1));
+            System.out.println("name=" + jdbcRS.getString(2));
+        }
+
+    }
+
+    // CachedRowSet Example
+    @Test
+    public void createCachedRowSet_DeleteRecord_ThenCorrect() throws Exception {
+
+        CachedRowSet crs = new CachedRowSetImpl();
+        crs.setUsername(username);
+        crs.setPassword(password);
+        crs.setUrl(url);
+        crs.setCommand(sql);
+        crs.execute();
+        crs.addRowSetListener(new ExampleListener());
+        while (crs.next()) {
+            if (crs.getInt("id") == 1) {
+                System.out.println("CRS found customer1 and will remove the record.");
+                crs.deleteRow();
+                break;
+            }
+        }
+    }
+
+    // WebRowSet example
+    @Test
+    public void createWebRowSet_SelectCustomers_WritetoXML_ThenCorrect() throws SQLException, IOException {
+
+        WebRowSet wrs = new WebRowSetImpl();
+        wrs.setUsername(username);
+        wrs.setPassword(password);
+        wrs.setUrl(url);
+        wrs.setCommand(sql);
+        wrs.execute();
+        FileOutputStream ostream = new FileOutputStream("customers.xml");
+        wrs.writeXml(ostream);
+    }
+
+    // JoinRowSet example
+    @Test
+    public void createCachedRowSets_DoJoinRowSet_ThenCorrect() throws Exception {
+
+        CachedRowSetImpl customers = new CachedRowSetImpl();
+        customers.setUsername(username);
+        customers.setPassword(password);
+        customers.setUrl(url);
+        customers.setCommand(sql);
+        customers.execute();
+
+        CachedRowSetImpl associates = new CachedRowSetImpl();
+        associates.setUsername(username);
+        associates.setPassword(password);
+        associates.setUrl(url);
+        String associatesSQL = "SELECT * FROM associates";
+        associates.setCommand(associatesSQL);
+        associates.execute();
+
+        JoinRowSet jrs = new JoinRowSetImpl();
+        final String ID = "id";
+        final String NAME = "name";
+        jrs.addRowSet(customers, ID);
+        jrs.addRowSet(associates, ID);
+        jrs.last();
+        System.out.println("Total rows: " + jrs.getRow());
+        jrs.beforeFirst();
+        while (jrs.next()) {
+
+            String string1 = jrs.getString(ID);
+            String string2 = jrs.getString(NAME);
+            System.out.println("ID: " + string1 + ", NAME: " + string2);
+        }
+    }
+
+    // FilteredRowSet example
+    @Test
+    public void createFilteredRowSet_filterByRegexExpression_thenCorrect() throws Exception {
+        RowSetFactory rsf = RowSetProvider.newFactory();
+        FilteredRowSet frs = rsf.createFilteredRowSet();
+        frs.setCommand("select * from customers");
+        Connection conn = DatabaseConfiguration.geth2Connection();
+        frs.execute(conn);
+        frs.setFilter(new FilterExample("^[A-C].*"));
+
+        ResultSetMetaData rsmd = frs.getMetaData();
+        int columncount = rsmd.getColumnCount();
+        while (frs.next()) {
+            for (int i = 1; i <= columncount; i++) {
+                System.out.println(rsmd.getColumnLabel(i) + " = " + frs.getObject(i) + " ");
+            }
+        }
+    }
+}

core-java/src/test/java/com/baeldung/loops/WhenUsingLoops.java

@@ -1,11 +1,38 @@
 package com.baeldung.loops;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
 import org.junit.Assert;
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 public class WhenUsingLoops {
 
     private LoopsInJava loops = new LoopsInJava();
+    private static List<String> list = new ArrayList<>();
+    private static Set<String> set = new HashSet<>();
+    private static Map<String, Integer> map = new HashMap<>();
+
+    @BeforeClass
+    public static void setUp() {
+        list.add("One");
+        list.add("Two");
+        list.add("Three");
+
+        set.add("Four");
+        set.add("Five");
+        set.add("Six");
+
+        map.put("One", 1);
+        map.put("Two", 2);
+        map.put("Three", 3);
+    }
 
     @Test
     public void shouldRunForLoop() {
@@ -34,4 +61,47 @@ public class WhenUsingLoops {
         int[] actual = loops.do_while_loop();
         Assert.assertArrayEquals(expected, actual);
     }
+
+    @Test
+    public void whenUsingSimpleFor_shouldIterateList() {
+        for (int i = 0; i < list.size(); i++) {
+            System.out.println(list.get(i));
+        }
+    }
+
+    @Test
+    public void whenUsingEnhancedFor_shouldIterateList() {
+        for (String item : list) {
+            System.out.println(item);
+        }
+    }
+
+    @Test
+    public void whenUsingEnhancedFor_shouldIterateSet() {
+        for (String item : set) {
+            System.out.println(item);
+        }
+    }
+
+    @Test
+    public void whenUsingEnhancedFor_shouldIterateMap() {
+        for (Entry<String, Integer> entry : map.entrySet()) {
+            System.out.println("Key: " + entry.getKey() + " - " + "Value: " + entry.getValue());
+        }
+    }
+
+    @Test
+    public void whenUsingSimpleFor_shouldRunLabelledLoop() {
+        aa: for (int i = 1; i <= 3; i++) {
+            if (i == 1)
+                continue;
+            bb: for (int j = 1; j <= 3; j++) {
+                if (i == 2 && j == 2) {
+                    break aa;
+                }
+                System.out.println(i + " " + j);
+            }
+        }
+    }
+
 }

core-java/src/test/java/com/baeldung/nestedclass/AnonymousInner.java

@@ -2,10 +2,14 @@ package com.baeldung.nestedclass;
 
 import org.junit.Test;
 
-public class AnonymousInnerTest {
+abstract class SimpleAbstractClass {
+    abstract void run();
+}
+
+public class AnonymousInner {
 
     @Test
-    public void whenRunAnonymousClass_thenCorrect() {
+    public void run() {
         SimpleAbstractClass simpleAbstractClass = new SimpleAbstractClass() {
             void run() {
                 System.out.println("Running Anonymous Class...");

core-java/src/test/java/com/baeldung/nestedclass/Enclosing.java

@@ -0,0 +1,21 @@
+package com.baeldung.nestedclass;
+
+import org.junit.Test;
+
+public class Enclosing {
+
+    private static int x = 1;
+
+    public static class StaticNested {
+
+        private void run() {
+            System.out.println("x = " + x);
+        }
+    }
+
+    @Test
+    public void test() {
+        Enclosing.StaticNested nested = new Enclosing.StaticNested();
+        nested.run();
+    }
+}

core-java/src/test/java/com/baeldung/nestedclass/InnerClassTest.java

@@ -1,13 +0,0 @@
-package com.baeldung.nestedclass;
-
-import org.junit.Test;
-
-public class InnerClassTest {
-
-    @Test
-    public void givenInnerClassWhenInstantiating_thenCorrect() {
-        Outer outer = new Outer();
-        Outer.Inner inner = outer.new Inner();
-        inner.test();
-    }
-}

core-java/src/test/java/com/baeldung/nestedclass/LocalClassTest.java

@@ -1,12 +0,0 @@
-package com.baeldung.nestedclass;
-
-import org.junit.Test;
-
-public class LocalClassTest {
-
-    @Test
-    public void whenTestingLocalClass_thenCorrect() {
-        NewEnclosing newEnclosing = new NewEnclosing();
-        newEnclosing.run();
-    }
-}

core-java/src/test/java/com/baeldung/nestedclass/NestedClassTest.java

@@ -1,12 +0,0 @@
-package com.baeldung.nestedclass;
-
-import org.junit.Test;
-
-public class NestedClassTest {
-
-    @Test
-    public void whenInstantiatingStaticNestedClass_thenCorrect() {
-        Enclosing.Nested nested = new Enclosing.Nested();
-        nested.test();
-    }
-}

core-java/src/test/java/com/baeldung/nestedclass/NewEnclosing.java

@@ -1,10 +1,11 @@
 package com.baeldung.nestedclass;
 
+import org.junit.Test;
+
 public class NewEnclosing {
 
-    void run() {
+    private void run() {
         class Local {
-
             void run() {
                 System.out.println("Welcome to Baeldung!");
             }
@@ -12,4 +13,10 @@ public class NewEnclosing {
         Local local = new Local();
         local.run();
     }
+
+    @Test
+    public void test() {
+        NewEnclosing newEnclosing = new NewEnclosing();
+        newEnclosing.run();
+    }
 }

core-java/src/test/java/com/baeldung/nestedclass/NewOuter.java

@@ -0,0 +1,30 @@
+package com.baeldung.nestedclass;
+
+import org.junit.Test;
+
+public class NewOuter {
+
+    int a = 1;
+    static int b = 2;
+
+    public class InnerClass {
+        int a = 3;
+        static final int b = 4;
+
+        public void run() {
+            System.out.println("a = " + a);
+            System.out.println("b = " + b);
+            System.out.println("NewOuter.this.a = " + NewOuter.this.a);
+            System.out.println("NewOuter.b = " + NewOuter.b);
+            System.out.println("NewOuter.this.b = " + NewOuter.this.b);
+        }
+    }
+
+    @Test
+    public void test() {
+        NewOuter outer = new NewOuter();
+        NewOuter.InnerClass inner = outer.new InnerClass();
+        inner.run();
+
+    }
+}

core-java/src/test/java/com/baeldung/nestedclass/NewOuterTest.java

@@ -1,32 +0,0 @@
-package com.baeldung.nestedclass;
-
-import static org.junit.Assert.assertEquals;
-import org.junit.Test;
-
-public class NewOuterTest {
-
-    int a = 1;
-    static int b = 2;
-
-    public class InnerClass {
-        int a = 3;
-        static final int b = 4;
-
-        @Test
-        public void whenShadowing_thenCorrect() {
-            assertEquals(3, a);
-            assertEquals(4, b);
-            assertEquals(1, NewOuterTest.this.a);
-            assertEquals(2, NewOuterTest.b);
-            assertEquals(2, NewOuterTest.this.b);
-        }
-    }
-
-    @Test
-    public void shadowingTest() {
-        NewOuterTest outer = new NewOuterTest();
-        NewOuterTest.InnerClass inner = outer.new InnerClass();
-        inner.whenShadowing_thenCorrect();
-
-    }
-}

core-java/src/test/java/com/baeldung/nestedclass/Outer.java

@@ -0,0 +1,20 @@
+package com.baeldung.nestedclass;
+
+import org.junit.Test;
+
+public class Outer {
+
+    public class Inner {
+
+        public void run() {
+            System.out.println("Calling test...");
+        }
+    }
+
+    @Test
+    public void test() {
+        Outer outer = new Outer();
+        Outer.Inner inner = outer.new Inner();
+        inner.run();
+    }
+}

core-java/src/test/java/com/baeldung/polymorphism/PolymorphismUnitTest.java

@@ -0,0 +1,32 @@
+package com.baeldung.polymorphism;
+
+import static org.junit.Assert.*;
+
+import java.awt.image.BufferedImage;
+import org.junit.Test;
+
+public class PolymorphismUnitTest {
+
+    @Test
+    public void givenImageFile_whenFileCreated_shouldSucceed() {
+        ImageFile imageFile = FileManager.createImageFile("SampleImageFile", 200, 100, new BufferedImage(100, 200, BufferedImage.TYPE_INT_RGB).toString()
+            .getBytes(), "v1.0.0");
+        assertEquals(200, imageFile.getHeight());
+    }
+
+    // Downcasting then Upcasting
+    @Test
+    public void givenTextFile_whenTextFileCreatedAndAssignedToGenericFileAndCastBackToTextFileOnGetWordCount_shouldSucceed() {
+        GenericFile textFile = FileManager.createTextFile("SampleTextFile", "This is a sample text content", "v1.0.0");
+        TextFile textFile2 = (TextFile) textFile;
+        assertEquals(6, textFile2.getWordCount());
+    }
+
+    // Downcasting
+    @Test(expected = ClassCastException.class)
+    public void givenGenericFile_whenCastToTextFileAndInvokeGetWordCount_shouldFail() {
+        GenericFile genericFile = new GenericFile();
+        TextFile textFile = (TextFile) genericFile;
+        System.out.println(textFile.getWordCount());
+    }
+}

core-java/src/test/java/com/baeldung/stream/FileCopyTest.java

@@ -0,0 +1,47 @@
+package com.baeldung.stream;
+
+import static org.junit.Assert.assertTrue;
+
+import java.io.File;
+import java.io.IOException;
+
+import org.junit.Test;
+
+public class FileCopyTest {
+
+    @Test
+    public void whenUsingStream_thenCopyFile() throws IOException {
+        File src = new File("src" + File.separator + "test" + File.separator + "resources" + File.separator + "copyTest" + File.separator + "src" + File.separator + "test_stream.txt");
+        File dest = new File("src" + File.separator + "test" + File.separator + "resources" + File.separator + "copyTest" + File.separator + "dest" + File.separator + "test_stream.txt");
+        FileCopy.copyFileUsingStream(src, dest);
+        assertTrue(dest.exists());
+        dest.delete();
+    }
+
+    @Test
+    public void whenUsingFiles_thenCopyFile() throws IOException {
+        File src = new File("src" + File.separator + "test" + File.separator + "resources" + File.separator + "copyTest" + File.separator + "src" + File.separator + "test_files.txt");
+        File dest = new File("src" + File.separator + "test" + File.separator + "resources" + File.separator + "copyTest" + File.separator + "dest" + File.separator + "test_files.txt");
+        FileCopy.copyFileUsingJavaFiles(src, dest);
+        assertTrue(dest.exists());
+        dest.delete();
+    }
+
+    @Test
+    public void whenUsingChannel_thenCopyFile() throws IOException {
+        File src = new File("src" + File.separator + "test" + File.separator + "resources" + File.separator + "copyTest" + File.separator + "src" + File.separator + "test_channel.txt");
+        File dest = new File("src" + File.separator + "test" + File.separator + "resources" + File.separator + "copyTest" + File.separator + "dest" + File.separator + "test_channel.txt");
+        FileCopy.copyFileUsingChannel(src, dest);
+        assertTrue(dest.exists());
+        dest.delete();
+    }
+
+    @Test
+    public void whenUsingApache_thenCopyFile() throws IOException {
+        File src = new File("src" + File.separator + "test" + File.separator + "resources" + File.separator + "copyTest" + File.separator + "src" + File.separator + "test_apache.txt");
+        File dest = new File("src" + File.separator + "test" + File.separator + "resources" + File.separator + "copyTest" + File.separator + "dest" + File.separator + "test_apache.txt");
+        FileCopy.copyFileUsingApacheCommonsIO(src, dest);
+        assertTrue(dest.exists());
+        dest.delete();
+    }
+}

core-java/src/test/java/com/baeldung/tree/BinaryTreeTest.java

@@ -0,0 +1,85 @@
+package com.baeldung.tree;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class BinaryTreeTest {
+
+    @Test
+    public void givenABinaryTree_WhenAddingElements_ThenTreeNotEmpty() {
+
+        BinaryTree bt = createBinaryTree();
+
+        assertTrue(!bt.isEmpty());
+    }
+
+    @Test
+    public void givenABinaryTree_WhenAddingElements_ThenTreeContainsThoseElements() {
+
+        BinaryTree bt = createBinaryTree();
+
+        assertTrue(bt.containsNode(6));
+        assertTrue(bt.containsNode(4));
+
+        assertFalse(bt.containsNode(1));
+    }
+
+    @Test
+    public void givenABinaryTree_WhenDeletingElements_ThenTreeDoesNotContainThoseElements() {
+
+        BinaryTree bt = createBinaryTree();
+
+        assertTrue(bt.containsNode(9));
+        bt.delete(9);
+        assertFalse(bt.containsNode(9));
+    }
+
+    @Test
+    public void givenABinaryTree_WhenTraversingInOrder_ThenPrintValues() {
+
+        BinaryTree bt = createBinaryTree();
+
+        bt.traverseInOrder(bt.root);
+    }
+
+    @Test
+    public void givenABinaryTree_WhenTraversingPreOrder_ThenPrintValues() {
+
+        BinaryTree bt = createBinaryTree();
+
+        bt.traversePreOrder(bt.root);
+    }
+
+    @Test
+    public void givenABinaryTree_WhenTraversingPostOrder_ThenPrintValues() {
+
+        BinaryTree bt = createBinaryTree();
+
+        bt.traversePostOrder(bt.root);
+    }
+
+    @Test
+    public void givenABinaryTree_WhenTraversingLevelOrder_ThenPrintValues() {
+
+        BinaryTree bt = createBinaryTree();
+
+        bt.traverseLevelOrder();
+    }
+
+    private BinaryTree createBinaryTree() {
+        BinaryTree bt = new BinaryTree();
+
+        bt.add(6);
+        bt.add(4);
+        bt.add(8);
+        bt.add(3);
+        bt.add(5);
+        bt.add(7);
+        bt.add(9);
+
+        return bt;
+    }
+
+}

core-java/src/test/resources/copyTest/dest/readme.txt

@@ -0,0 +1,2 @@
+files will be copied here and then deleted
+remove `file.delete()` to see the files here 

core-java/src/test/resources/copyTest/src/test_apache.txt

@@ -0,0 +1 @@
+apache

core-java/src/test/resources/copyTest/src/test_channel.txt

@@ -0,0 +1 @@
+channel

core-java/src/test/resources/copyTest/src/test_files.txt

@@ -0,0 +1 @@
+files

core-java/src/test/resources/copyTest/src/test_stream.txt

@@ -0,0 +1 @@
+stream

core-kotlin/src/test/kotlin/com/baeldung/kotlin/ExtensionMethods.kt

@@ -0,0 +1,51 @@
+package com.baeldung.kotlin
+
+import org.junit.Assert
+import org.junit.Test
+
+class ExtensionMethods {
+    @Test
+    fun simpleExtensionMethod() {
+        fun String.escapeForXml() : String {
+            return this
+                    .replace("&", "&")
+                    .replace("<", "&lt;")
+                    .replace(">", "&gt;")
+        }
+
+        Assert.assertEquals("Nothing", "Nothing".escapeForXml())
+        Assert.assertEquals("&lt;Tag&gt;", "<Tag>".escapeForXml())
+        Assert.assertEquals("a&amp;b", "a&b".escapeForXml())
+    }
+
+    @Test
+    fun genericExtensionMethod() {
+        fun <T> T.concatAsString(b: T) : String {
+            return this.toString() + b.toString()
+        }
+
+        Assert.assertEquals("12", "1".concatAsString("2"))
+        Assert.assertEquals("12", 1.concatAsString(2))
+        // This doesn't compile
+        // Assert.assertEquals("12", 1.concatAsString(2.0))
+    }
+
+    @Test
+    fun infixExtensionMethod() {
+        infix fun Number.toPowerOf(exponent: Number): Double {
+            return Math.pow(this.toDouble(), exponent.toDouble())
+        }
+
+        Assert.assertEquals(9.0, 3 toPowerOf 2, 0.1)
+        Assert.assertEquals(3.0, 9 toPowerOf 0.5, 0.1)
+    }
+
+    @Test
+    fun operatorExtensionMethod() {
+        operator fun List<Int>.times(by: Int): List<Int> {
+            return this.map { it * by }
+        }
+
+        Assert.assertEquals(listOf(2, 4, 6), listOf(1, 2, 3) * 2)
+    }
+}

drools/README.MD

@@ -1,3 +1,4 @@
 ### Relevant Articles:
 - [Introduction to Drools](http://www.baeldung.com/drools)
 - [Drools Using Rules from Excel Files](http://www.baeldung.com/drools-excel)
+- [An Example of Backward Chaining in Drools](http://www.baeldung.com/drools-backward-chaining)

dubbo/README.md

@@ -0,0 +1,4 @@
+## Relevant articles:
+
+- [Intro to Dubbo](http://www.baeldung.com/dubbo-intro)
+

dubbo/pom.xml

@@ -0,0 +1,72 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <artifactId>parent-modules</artifactId>
+        <groupId>com.baeldung</groupId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>dubbo</artifactId>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+        <java.version>1.8</java.version>
+        <dubbo.version>2.5.7</dubbo.version>
+        <zookeeper.version>3.4.11</zookeeper.version>
+        <zkclient.version>0.10</zkclient.version>
+        <surefire.version>2.19.1</surefire.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>dubbo</artifactId>
+            <version>${dubbo.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.zookeeper</groupId>
+            <artifactId>zookeeper</artifactId>
+            <version>${zookeeper.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.101tec</groupId>
+            <artifactId>zkclient</artifactId>
+            <version>${zkclient.version}</version>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>${surefire.version}</version>
+                <configuration>
+                    <excludes>
+                        <exclude>**/*LiveTest.java</exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

dubbo/src/main/java/com/alibaba/dubbo/registry/simple/SimpleRegistryService.java

@@ -0,0 +1,210 @@
+/*
+ * Copyright 1999-2011 Alibaba Group.
+ *  
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *  
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *  
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.alibaba.dubbo.registry.simple;
+
+import com.alibaba.dubbo.common.Constants;
+import com.alibaba.dubbo.common.URL;
+import com.alibaba.dubbo.common.logger.Logger;
+import com.alibaba.dubbo.common.logger.LoggerFactory;
+import com.alibaba.dubbo.common.utils.ConcurrentHashSet;
+import com.alibaba.dubbo.common.utils.NetUtils;
+import com.alibaba.dubbo.common.utils.UrlUtils;
+import com.alibaba.dubbo.registry.NotifyListener;
+import com.alibaba.dubbo.registry.RegistryService;
+import com.alibaba.dubbo.registry.support.AbstractRegistry;
+import com.alibaba.dubbo.rpc.RpcContext;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+/**
+ * SimpleRegistryService
+ *
+ * @author william.liangf
+ */
+public class SimpleRegistryService extends AbstractRegistry {
+
+    private final static Logger logger = LoggerFactory.getLogger(SimpleRegistryService.class);
+    private final ConcurrentMap<String, Set<URL>> remoteRegistered = new ConcurrentHashMap<String, Set<URL>>();
+    private final ConcurrentMap<String, ConcurrentMap<URL, Set<NotifyListener>>> remoteSubscribed = new ConcurrentHashMap<String, ConcurrentMap<URL, Set<NotifyListener>>>();
+
+    public SimpleRegistryService() {
+        super(new URL("dubbo", NetUtils.getLocalHost(), 0, RegistryService.class.getName(), "file", "N/A"));
+    }
+
+    public boolean isAvailable() {
+        return true;
+    }
+
+    public List<URL> lookup(URL url) {
+        List<URL> urls = new ArrayList<URL>();
+        for (URL u : getRegistered()) {
+            if (UrlUtils.isMatch(url, u)) {
+                urls.add(u);
+            }
+        }
+        return urls;
+    }
+
+    public void register(URL url) {
+        String client = RpcContext.getContext().getRemoteAddressString();
+        Set<URL> urls = remoteRegistered.get(client);
+        if (urls == null) {
+            remoteRegistered.putIfAbsent(client, new ConcurrentHashSet<URL>());
+            urls = remoteRegistered.get(client);
+        }
+        urls.add(url);
+        super.register(url);
+        registered(url);
+    }
+
+    public void unregister(URL url) {
+        String client = RpcContext.getContext().getRemoteAddressString();
+        Set<URL> urls = remoteRegistered.get(client);
+        if (urls != null && urls.size() > 0) {
+            urls.remove(url);
+        }
+        super.unregister(url);
+        unregistered(url);
+    }
+
+    public void subscribe(URL url, NotifyListener listener) {
+        if (getUrl().getPort() == 0) {
+            URL registryUrl = RpcContext.getContext().getUrl();
+            if (registryUrl != null && registryUrl.getPort() > 0
+                    && RegistryService.class.getName().equals(registryUrl.getPath())) {
+                super.setUrl(registryUrl);
+                super.register(registryUrl);
+            }
+        }
+        String client = RpcContext.getContext().getRemoteAddressString();
+        ConcurrentMap<URL, Set<NotifyListener>> clientListeners = remoteSubscribed.get(client);
+        if (clientListeners == null) {
+            remoteSubscribed.putIfAbsent(client, new ConcurrentHashMap<URL, Set<NotifyListener>>());
+            clientListeners = remoteSubscribed.get(client);
+        }
+        Set<NotifyListener> listeners = clientListeners.get(url);
+        if (listeners == null) {
+            clientListeners.putIfAbsent(url, new ConcurrentHashSet<NotifyListener>());
+            listeners = clientListeners.get(url);
+        }
+        listeners.add(listener);
+        super.subscribe(url, listener);
+        subscribed(url, listener);
+    }
+
+    public void unsubscribe(URL url, NotifyListener listener) {
+        if (!Constants.ANY_VALUE.equals(url.getServiceInterface())
+                && url.getParameter(Constants.REGISTER_KEY, true)) {
+            unregister(url);
+        }
+        String client = RpcContext.getContext().getRemoteAddressString();
+        Map<URL, Set<NotifyListener>> clientListeners = remoteSubscribed.get(client);
+        if (clientListeners != null && clientListeners.size() > 0) {
+            Set<NotifyListener> listeners = clientListeners.get(url);
+            if (listeners != null && listeners.size() > 0) {
+                listeners.remove(listener);
+            }
+        }
+    }
+
+    protected void registered(URL url) {
+        for (Map.Entry<URL, Set<NotifyListener>> entry : getSubscribed().entrySet()) {
+            URL key = entry.getKey();
+            if (UrlUtils.isMatch(key, url)) {
+                List<URL> list = lookup(key);
+                for (NotifyListener listener : entry.getValue()) {
+                    listener.notify(list);
+                }
+            }
+        }
+    }
+
+    protected void unregistered(URL url) {
+        for (Map.Entry<URL, Set<NotifyListener>> entry : getSubscribed().entrySet()) {
+            URL key = entry.getKey();
+            if (UrlUtils.isMatch(key, url)) {
+                List<URL> list = lookup(key);
+                for (NotifyListener listener : entry.getValue()) {
+                    listener.notify(list);
+                }
+            }
+        }
+    }
+
+    protected void subscribed(final URL url, final NotifyListener listener) {
+        if (Constants.ANY_VALUE.equals(url.getServiceInterface())) {
+            new Thread(new Runnable() {
+                public void run() {
+                    Map<String, List<URL>> map = new HashMap<String, List<URL>>();
+                    for (URL u : getRegistered()) {
+                        if (UrlUtils.isMatch(url, u)) {
+                            String service = u.getServiceInterface();
+                            List<URL> list = map.get(service);
+                            if (list == null) {
+                                list = new ArrayList<URL>();
+                                map.put(service, list);
+                            }
+                            list.add(u);
+                        }
+                    }
+                    for (List<URL> list : map.values()) {
+                        try {
+                            listener.notify(list);
+                        } catch (Throwable e) {
+                            logger.warn("Discard to notify " + url.getServiceKey() + " to listener " + listener);
+                        }
+                    }
+                }
+            }, "DubboMonitorNotifier").start();
+        } else {
+            List<URL> list = lookup(url);
+            try {
+                listener.notify(list);
+            } catch (Throwable e) {
+                logger.warn("Discard to notify " + url.getServiceKey() + " to listener " + listener);
+            }
+        }
+    }
+
+    public void disconnect() {
+        String client = RpcContext.getContext().getRemoteAddressString();
+        if (logger.isInfoEnabled()) {
+            logger.info("Disconnected " + client);
+        }
+        Set<URL> urls = remoteRegistered.get(client);
+        if (urls != null && urls.size() > 0) {
+            for (URL url : urls) {
+                unregister(url);
+            }
+        }
+        Map<URL, Set<NotifyListener>> listeners = remoteSubscribed.get(client);
+        if (listeners != null && listeners.size() > 0) {
+            for (Map.Entry<URL, Set<NotifyListener>> entry : listeners.entrySet()) {
+                URL url = entry.getKey();
+                for (NotifyListener listener : entry.getValue()) {
+                    unsubscribe(url, listener);
+                }
+            }
+        }
+    }
+
+}

dubbo/src/main/java/com/baeldung/dubbo/remote/GreetingsFailoverServiceImpl.java

@@ -0,0 +1,14 @@
+package com.baeldung.dubbo.remote;
+
+/**
+ * @author aiet
+ */
+public class GreetingsFailoverServiceImpl implements GreetingsService {
+
+    @Override
+    public String sayHi(String name) {
+        System.out.println("failover implementation");
+        return "hi, failover " + name;
+    }
+
+}

dubbo/src/main/java/com/baeldung/dubbo/remote/GreetingsService.java

@@ -0,0 +1,10 @@
+package com.baeldung.dubbo.remote;
+
+/**
+ * @author aiet
+ */
+public interface GreetingsService {
+
+    String sayHi(String name);
+
+}

dubbo/src/main/java/com/baeldung/dubbo/remote/GreetingsServiceImpl.java

@@ -0,0 +1,14 @@
+package com.baeldung.dubbo.remote;
+
+/**
+ * @author aiet
+ */
+public class GreetingsServiceImpl implements GreetingsService {
+
+    @Override
+    public String sayHi(String name) {
+        System.out.println("default implementation");
+        return "hi, " + name;
+    }
+
+}

dubbo/src/main/java/com/baeldung/dubbo/remote/GreetingsServiceSpecialImpl.java

@@ -0,0 +1,20 @@
+package com.baeldung.dubbo.remote;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+/**
+ * @author aiet
+ */
+public class GreetingsServiceSpecialImpl implements GreetingsService {
+
+    @Override
+    public String sayHi(String name) {
+        try {
+            System.out.println("specially called");
+            SECONDS.sleep(5);
+        } catch (Exception ignored) {
+        }
+        return "hi, " + name;
+    }
+
+}

dubbo/src/test/java/com/baeldung/dubbo/APIConfigurationLiveTest.java

@@ -0,0 +1,57 @@
+package com.baeldung.dubbo;
+
+import com.alibaba.dubbo.config.ApplicationConfig;
+import com.alibaba.dubbo.config.ReferenceConfig;
+import com.alibaba.dubbo.config.RegistryConfig;
+import com.alibaba.dubbo.config.ServiceConfig;
+import com.baeldung.dubbo.remote.GreetingsService;
+import com.baeldung.dubbo.remote.GreetingsServiceImpl;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author aiet
+ */
+public class APIConfigurationLiveTest {
+
+    @Before
+    public void initProvider() {
+        ApplicationConfig application = new ApplicationConfig();
+        application.setName("demo-provider");
+        application.setVersion("1.0");
+
+        RegistryConfig registryConfig = new RegistryConfig();
+        registryConfig.setAddress("multicast://224.1.1.1:9090");
+
+        ServiceConfig<GreetingsService> service = new ServiceConfig<>();
+        service.setApplication(application);
+        service.setRegistry(registryConfig);
+        service.setInterface(GreetingsService.class);
+        service.setRef(new GreetingsServiceImpl());
+
+        service.export();
+    }
+
+    @Test
+    public void givenProviderConsumer_whenSayHi_thenGotResponse() {
+        ApplicationConfig application = new ApplicationConfig();
+        application.setName("demo-consumer");
+        application.setVersion("1.0");
+
+        RegistryConfig registryConfig = new RegistryConfig();
+        registryConfig.setAddress("multicast://224.1.1.1:9090");
+
+        ReferenceConfig<GreetingsService> reference = new ReferenceConfig<>();
+        reference.setApplication(application);
+        reference.setRegistry(registryConfig);
+        reference.setInterface(GreetingsService.class);
+
+        GreetingsService greetingsService = reference.get();
+        String hiMessage = greetingsService.sayHi("baeldung");
+
+        assertEquals("hi, baeldung", hiMessage);
+    }
+
+}

dubbo/src/test/java/com/baeldung/dubbo/ClusterDynamicLoadBalanceLiveTest.java

@@ -0,0 +1,70 @@
+package com.baeldung.dubbo;
+
+import com.baeldung.dubbo.remote.GreetingsService;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.OptionalDouble;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * @author aiet
+ */
+public class ClusterDynamicLoadBalanceLiveTest {
+
+    private ExecutorService executorService;
+
+    @Before
+    public void initRemote() {
+        executorService = Executors.newFixedThreadPool(2);
+        executorService.submit(() -> {
+            ClassPathXmlApplicationContext remoteContext = new ClassPathXmlApplicationContext("cluster/provider-app-default.xml");
+            remoteContext.start();
+        });
+        executorService.submit(() -> {
+            SECONDS.sleep(2);
+            ClassPathXmlApplicationContext backupRemoteContext = new ClassPathXmlApplicationContext("cluster/provider-app-special.xml");
+            backupRemoteContext.start();
+            return null;
+        });
+    }
+
+    @Test
+    public void givenProviderCluster_whenConsumerSaysHi_thenResponseBalanced() throws InterruptedException {
+        ClassPathXmlApplicationContext localContext = new ClassPathXmlApplicationContext("cluster/consumer-app-lb.xml");
+        localContext.start();
+        GreetingsService greetingsService = (GreetingsService) localContext.getBean("greetingsService");
+        List<Long> elapseList = new ArrayList<>(6);
+        for (int i = 0; i < 6; i++) {
+            long current = System.currentTimeMillis();
+            String hiMessage = greetingsService.sayHi("baeldung");
+            assertNotNull(hiMessage);
+            elapseList.add(System.currentTimeMillis() - current);
+            SECONDS.sleep(1);
+        }
+
+        OptionalDouble avgElapse = elapseList
+          .stream()
+          .mapToLong(e -> e)
+          .average();
+        assertTrue(avgElapse.isPresent());
+        assertTrue(avgElapse.getAsDouble() > 1666.0);
+
+    }
+
+    @After
+    public void destroy() {
+        executorService.shutdown();
+    }
+
+}

dubbo/src/test/java/com/baeldung/dubbo/ClusterFailoverLiveTest.java

@@ -0,0 +1,52 @@
+package com.baeldung.dubbo;
+
+import com.baeldung.dubbo.remote.GreetingsService;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+/**
+ * @author aiet
+ */
+public class ClusterFailoverLiveTest {
+
+    private ExecutorService executorService;
+
+    @Before
+    public void initRemote() {
+        executorService = Executors.newFixedThreadPool(2);
+        executorService.submit(() -> {
+            ClassPathXmlApplicationContext backupRemoteContext = new ClassPathXmlApplicationContext("cluster/provider-app-special.xml");
+            backupRemoteContext.start();
+        });
+        executorService.submit(() -> {
+            ClassPathXmlApplicationContext remoteContext = new ClassPathXmlApplicationContext("cluster/provider-app-failover.xml");
+            remoteContext.start();
+        });
+
+    }
+
+    @Test
+    public void givenProviderCluster_whenConsumerSaysHi_thenGotFailoverResponse() {
+        ClassPathXmlApplicationContext localContext = new ClassPathXmlApplicationContext("cluster/consumer-app-failtest.xml");
+        localContext.start();
+        GreetingsService greetingsService = (GreetingsService) localContext.getBean("greetingsService");
+        String hiMessage = greetingsService.sayHi("baeldung");
+
+        assertNotNull(hiMessage);
+        assertEquals("hi, failover baeldung", hiMessage);
+    }
+
+    @After
+    public void destroy() {
+        executorService.shutdown();
+    }
+
+}

dubbo/src/test/java/com/baeldung/dubbo/ClusterFailsafeLiveTest.java

@@ -0,0 +1,47 @@
+package com.baeldung.dubbo;
+
+import com.baeldung.dubbo.remote.GreetingsService;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+/**
+ * @author aiet
+ */
+public class ClusterFailsafeLiveTest {
+
+    private ExecutorService executorService;
+
+    @Before
+    public void initRemote() {
+        executorService = Executors.newFixedThreadPool(1);
+        executorService.submit(() -> {
+            ClassPathXmlApplicationContext remoteContext = new ClassPathXmlApplicationContext("cluster/provider-app-special-failsafe.xml");
+            remoteContext.start();
+        });
+    }
+
+    @Test
+    public void givenProviderCluster_whenConsumerSaysHi_thenGotFailsafeResponse() {
+        ClassPathXmlApplicationContext localContext = new ClassPathXmlApplicationContext("cluster/consumer-app-failtest.xml");
+        localContext.start();
+        GreetingsService greetingsService = (GreetingsService) localContext.getBean("greetingsService");
+        String hiMessage = greetingsService.sayHi("baeldung");
+
+        assertNull(hiMessage);
+    }
+
+    @After
+    public void destroy() {
+        executorService.shutdown();
+    }
+
+}

dubbo/src/test/java/com/baeldung/dubbo/ClusterLoadBalanceLiveTest.java

@@ -0,0 +1,66 @@
+package com.baeldung.dubbo;
+
+import com.baeldung.dubbo.remote.GreetingsService;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.OptionalDouble;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * @author aiet
+ */
+public class ClusterLoadBalanceLiveTest {
+
+    private ExecutorService executorService;
+
+    @Before
+    public void initRemote() {
+        executorService = Executors.newFixedThreadPool(2);
+        executorService.submit(() -> {
+            ClassPathXmlApplicationContext remoteContext = new ClassPathXmlApplicationContext("cluster/provider-app-default.xml");
+            remoteContext.start();
+        });
+        executorService.submit(() -> {
+            ClassPathXmlApplicationContext backupRemoteContext = new ClassPathXmlApplicationContext("cluster/provider-app-special.xml");
+            backupRemoteContext.start();
+        });
+    }
+
+    @Test
+    public void givenProviderCluster_whenConsumerSaysHi_thenResponseBalanced() {
+        ClassPathXmlApplicationContext localContext = new ClassPathXmlApplicationContext("cluster/consumer-app-lb.xml");
+        localContext.start();
+        GreetingsService greetingsService = (GreetingsService) localContext.getBean("greetingsService");
+        List<Long> elapseList = new ArrayList<>(6);
+        for (int i = 0; i < 6; i++) {
+            long current = System.currentTimeMillis();
+            String hiMessage = greetingsService.sayHi("baeldung");
+            assertNotNull(hiMessage);
+            elapseList.add(System.currentTimeMillis() - current);
+        }
+
+        OptionalDouble avgElapse = elapseList
+          .stream()
+          .mapToLong(e -> e)
+          .average();
+        assertTrue(avgElapse.isPresent());
+        System.out.println(avgElapse.getAsDouble());
+        assertTrue(avgElapse.getAsDouble() > 2500.0);
+
+    }
+
+    @After
+    public void destroy() {
+        executorService.shutdown();
+    }
+
+}

dubbo/src/test/java/com/baeldung/dubbo/MulticastRegistryLiveTest.java

@@ -0,0 +1,36 @@
+package com.baeldung.dubbo;
+
+import com.baeldung.dubbo.remote.GreetingsService;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+/**
+ * @author aiet
+ */
+public class MulticastRegistryLiveTest {
+
+    private ClassPathXmlApplicationContext remoteContext;
+
+    @Before
+    public void initRemote() {
+        remoteContext = new ClassPathXmlApplicationContext("multicast/provider-app.xml");
+        remoteContext.start();
+    }
+
+    @Test
+    public void givenProvider_whenConsumerSaysHi_thenGotResponse() {
+        ClassPathXmlApplicationContext localContext = new ClassPathXmlApplicationContext("multicast/consumer-app.xml");
+        localContext.start();
+        GreetingsService greetingsService = (GreetingsService) localContext.getBean("greetingsService");
+        String hiMessage = greetingsService.sayHi("baeldung");
+
+        assertNotNull(hiMessage);
+        assertEquals("hi, baeldung", hiMessage);
+    }
+
+}

dubbo/src/test/java/com/baeldung/dubbo/ResultCacheLiveTest.java

@@ -0,0 +1,47 @@
+package com.baeldung.dubbo;
+
+import com.baeldung.dubbo.remote.GreetingsService;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+import static org.junit.Assert.*;
+
+/**
+ * @author aiet
+ */
+public class ResultCacheLiveTest {
+
+    private ClassPathXmlApplicationContext remoteContext;
+
+    @Before
+    public void initRemote() {
+        remoteContext = new ClassPathXmlApplicationContext("multicast/provider-app-special.xml");
+        remoteContext.start();
+    }
+
+    @Test
+    public void givenProvider_whenConsumerSaysHi_thenGotResponse() {
+        ClassPathXmlApplicationContext localContext = new ClassPathXmlApplicationContext("multicast/consumer-app.xml");
+        localContext.start();
+        GreetingsService greetingsService = (GreetingsService) localContext.getBean("greetingsService");
+
+        long before = System.currentTimeMillis();
+        String hiMessage = greetingsService.sayHi("baeldung");
+
+        long timeElapsed = System.currentTimeMillis() - before;
+        assertTrue(timeElapsed > 5000);
+        assertNotNull(hiMessage);
+        assertEquals("hi, baeldung", hiMessage);
+
+
+        before = System.currentTimeMillis();
+        hiMessage = greetingsService.sayHi("baeldung");
+        timeElapsed = System.currentTimeMillis() - before;
+        assertTrue(timeElapsed < 1000);
+        assertNotNull(hiMessage);
+        assertEquals("hi, baeldung", hiMessage);
+    }
+
+}

dubbo/src/test/java/com/baeldung/dubbo/SimpleRegistryLiveTest.java

@@ -0,0 +1,39 @@
+package com.baeldung.dubbo;
+
+import com.baeldung.dubbo.remote.GreetingsService;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+/**
+ * @author aiet
+ */
+public class SimpleRegistryLiveTest {
+
+    private ClassPathXmlApplicationContext remoteContext;
+    private ClassPathXmlApplicationContext registryContext;
+
+    @Before
+    public void initRemote() {
+        registryContext = new ClassPathXmlApplicationContext("simple/registry.xml");
+        registryContext.start();
+
+        remoteContext = new ClassPathXmlApplicationContext("simple/provider-app.xml");
+        remoteContext.start();
+    }
+
+    @Test
+    public void givenProvider_whenConsumerSaysHi_thenGotResponse() {
+        ClassPathXmlApplicationContext localContext = new ClassPathXmlApplicationContext("simple/consumer-app.xml");
+        localContext.start();
+        GreetingsService greetingsService = (GreetingsService) localContext.getBean("greetingsService");
+        String hiMessage = greetingsService.sayHi("baeldung");
+
+        assertNotNull(hiMessage);
+        assertEquals("hi, baeldung", hiMessage);
+    }
+
+}

dubbo/src/test/resources/cluster/consumer-app-failtest.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
+
+    <!-- provider application meta -->
+    <dubbo:application name="demo-consumer" version="1.0"/>
+
+    <!-- address used to expose provider's service  -->
+    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
+
+    <!-- remote service proxy, acting like a local bean while invoking -->
+    <dubbo:reference interface="com.baeldung.dubbo.remote.GreetingsService" id="greetingsService" retries="2" timeout="2000" />
+
+</beans>

dubbo/src/test/resources/cluster/consumer-app-lb.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
+
+    <!-- provider application meta -->
+    <dubbo:application name="demo-consumer" version="1.0"/>
+
+    <!-- address used to expose provider's service  -->
+    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
+
+    <!-- remote service proxy, acting like a local bean while invoking -->
+    <dubbo:reference interface="com.baeldung.dubbo.remote.GreetingsService" id="greetingsService" retries="2" timeout="10000" loadbalance="roundrobin" />
+
+</beans>

dubbo/src/test/resources/cluster/provider-app-default.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
+
+    <!-- provider application meta -->
+    <dubbo:application name="demo-provider" version="1.0"/>
+
+    <!-- address used to expose provider's service  -->
+    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
+
+    <!-- protocol and port used to expose service -->
+    <dubbo:protocol name="dubbo" port="20880"/>
+
+    <!-- the service interface to expose -->
+    <dubbo:service interface="com.baeldung.dubbo.remote.GreetingsService" ref="greetingsService" cluster="failsafe"/>
+
+    <!-- declare the local implementation of exposed service interface -->
+    <bean id="greetingsService" class="com.baeldung.dubbo.remote.GreetingsServiceImpl"/>
+
+</beans>

dubbo/src/test/resources/cluster/provider-app-failover.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
+
+    <!-- provider application meta -->
+    <dubbo:application name="demo-provider" version="1.0"/>
+
+    <!-- address used to expose provider's service  -->
+    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
+
+    <!-- protocol and port used to expose service -->
+    <dubbo:protocol name="dubbo" port="20880"/>
+
+    <!-- the service interface to expose -->
+    <dubbo:service interface="com.baeldung.dubbo.remote.GreetingsService" ref="greetingsService" cluster="failover"/>
+
+    <!-- declare the local implementation of exposed service interface -->
+    <bean id="greetingsService" class="com.baeldung.dubbo.remote.GreetingsFailoverServiceImpl"/>
+
+</beans>

dubbo/src/test/resources/cluster/provider-app-special-failsafe.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
+
+    <!-- provider application meta -->
+    <dubbo:application name="demo-provider" version="1.0"/>
+
+    <!-- address used to expose provider's service  -->
+    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
+
+    <!-- protocol and port used to expose service -->
+    <dubbo:protocol name="dubbo" port="20881" />
+
+    <!-- the service interface to expose -->
+    <dubbo:service interface="com.baeldung.dubbo.remote.GreetingsService" ref="greetingsService" cluster="failsafe"/>
+
+    <!-- declare the local implementation of exposed service interface -->
+    <bean id="greetingsService" class="com.baeldung.dubbo.remote.GreetingsServiceSpecialImpl"/>
+
+</beans>

dubbo/src/test/resources/cluster/provider-app-special.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
+
+    <!-- provider application meta -->
+    <dubbo:application name="demo-provider" version="1.0"/>
+
+    <!-- address used to expose provider's service  -->
+    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
+
+    <!-- protocol and port used to expose service -->
+    <dubbo:protocol name="dubbo" port="20881" />
+
+    <!-- the service interface to expose -->
+    <dubbo:service interface="com.baeldung.dubbo.remote.GreetingsService" ref="greetingsService" cluster="failover"/>
+
+    <!-- declare the local implementation of exposed service interface -->
+    <bean id="greetingsService" class="com.baeldung.dubbo.remote.GreetingsServiceSpecialImpl"/>
+
+</beans>

dubbo/src/test/resources/log4j.properties

@@ -0,0 +1,6 @@
+log4j.rootLogger=INFO, stdout
+
+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

dubbo/src/test/resources/multicast/consumer-app.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
+
+    <!-- provider application meta -->
+    <dubbo:application name="demo-consumer" version="1.0"/>
+
+    <!-- address used to expose provider's service  -->
+    <dubbo:registry address="multicast://224.1.1.1:9090"/>
+
+    <!-- remote service proxy, acting like a local bean while invoking -->
+    <dubbo:reference interface="com.baeldung.dubbo.remote.GreetingsService" id="greetingsService" cache="lru" />
+
+</beans>