Merge remote-tracking branch 'upstream/master'

# Conflicts:
#	pom.xml

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "testgitrepo"]
+	path = testgitrepo
+	url = /home/prd/Development/projects/idea/tutorials/spring-boot/src/main/resources/testgitrepo/

annotations/annotation-processing/pom.xml

@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <version>1.0.0-SNAPSHOT</version>
+        <artifactId>annotations</artifactId>
+        <relativePath>../</relativePath>
+    </parent>
+
+    <artifactId>annotation-processing</artifactId>
+
+    <properties>
+        <auto-service.version>1.0-rc2</auto-service.version>
+        <maven-compiler-plugin.version>3.5.1</maven-compiler-plugin.version>
+    </properties>
+
+    <dependencies>
+
+        <dependency>
+            <groupId>com.google.auto.service</groupId>
+            <artifactId>auto-service</artifactId>
+            <version>${auto-service.version}</version>
+            <scope>provided</scope>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+
+        <plugins>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+
+        </plugins>
+
+    </build>
+
+</project>

annotations/annotation-processing/src/main/java/com/baeldung/annotation/processor/BuilderProcessor.java

@@ -0,0 +1,132 @@
+package com.baeldung.annotation.processor;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import javax.annotation.processing.*;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.ExecutableType;
+import javax.tools.Diagnostic;
+import javax.tools.JavaFileObject;
+
+import com.google.auto.service.AutoService;
+
+@SupportedAnnotationTypes("com.baeldung.annotation.processor.BuilderProperty")
+@SupportedSourceVersion(SourceVersion.RELEASE_8)
+@AutoService(Processor.class)
+public class BuilderProcessor extends AbstractProcessor {
+
+    @Override
+    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+        for (TypeElement annotation : annotations) {
+
+            Set<? extends Element> annotatedElements = roundEnv.getElementsAnnotatedWith(annotation);
+
+            Map<Boolean, List<Element>> annotatedMethods = annotatedElements.stream()
+                    .collect(Collectors.partitioningBy(element ->
+                            ((ExecutableType) element.asType()).getParameterTypes().size() == 1
+                                    && element.getSimpleName().toString().startsWith("set")));
+
+            List<Element> setters = annotatedMethods.get(true);
+            List<Element> otherMethods = annotatedMethods.get(false);
+
+            otherMethods.forEach(element ->
+                    processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,
+                            "@BuilderProperty must be applied to a setXxx method with a single argument", element));
+
+            if (setters.isEmpty()) {
+                continue;
+            }
+
+            String className = ((TypeElement) setters.get(0).getEnclosingElement()).getQualifiedName().toString();
+
+            Map<String, String> setterMap = setters.stream().collect(Collectors.toMap(
+                    setter -> setter.getSimpleName().toString(),
+                    setter -> ((ExecutableType) setter.asType())
+                            .getParameterTypes().get(0).toString()
+            ));
+
+            try {
+                writeBuilderFile(className, setterMap);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+
+        }
+
+        return true;
+    }
+
+    private void writeBuilderFile(String className, Map<String, String> setterMap) throws IOException {
+
+        String packageName = null;
+        int lastDot = className.lastIndexOf('.');
+        if (lastDot > 0) {
+            packageName = className.substring(0, lastDot);
+        }
+
+        String simpleClassName = className.substring(lastDot + 1);
+        String builderClassName = className + "Builder";
+        String builderSimpleClassName = builderClassName.substring(lastDot + 1);
+
+        JavaFileObject builderFile = processingEnv.getFiler().createSourceFile(builderClassName);
+        try (PrintWriter out = new PrintWriter(builderFile.openWriter())) {
+
+            if (packageName != null) {
+                out.print("package ");
+                out.print(packageName);
+                out.println(";");
+                out.println();
+            }
+
+            out.print("public class ");
+            out.print(builderSimpleClassName);
+            out.println(" {");
+            out.println();
+
+            out.print("    private ");
+            out.print(simpleClassName);
+            out.print(" object = new ");
+            out.print(simpleClassName);
+            out.println("();");
+            out.println();
+
+            out.print("    public ");
+            out.print(simpleClassName);
+            out.println(" build() {");
+            out.println("        return object;");
+            out.println("    }");
+            out.println();
+
+            setterMap.entrySet().forEach(setter -> {
+                String methodName = setter.getKey();
+                String argumentType = setter.getValue();
+
+                out.print("    public ");
+                out.print(builderSimpleClassName);
+                out.print(" ");
+                out.print(methodName);
+
+                out.print("(");
+
+                out.print(argumentType);
+                out.println(" value) {");
+                out.print("        object.");
+                out.print(methodName);
+                out.println("(value);");
+                out.println("        return this;");
+                out.println("    }");
+                out.println();
+            });
+
+            out.println("}");
+
+        }
+    }
+
+}

annotations/annotation-processing/src/main/java/com/baeldung/annotation/processor/BuilderProperty.java

@@ -0,0 +1,8 @@
+package com.baeldung.annotation.processor;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.SOURCE)
+public @interface BuilderProperty {
+}

annotations/annotation-user/pom.xml

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <artifactId>annotations</artifactId>
+        <groupId>com.baeldung</groupId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../</relativePath>
+    </parent>
+
+    <artifactId>annotation-user</artifactId>
+
+    <dependencies>
+
+        <dependency>
+            <groupId>com.baeldung</groupId>
+            <artifactId>annotation-processing</artifactId>
+            <version>${project.parent.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+
+        <plugins>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.5.1</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+
+        </plugins>
+
+    </build>
+
+</project>

annotations/annotation-user/src/main/java/com/baeldung/annotation/Person.java

@@ -0,0 +1,29 @@
+package com.baeldung.annotation;
+
+import com.baeldung.annotation.processor.BuilderProperty;
+
+public class Person {
+
+    private int age;
+
+    private String name;
+
+    public int getAge() {
+        return age;
+    }
+
+    @BuilderProperty
+    public void setAge(int age) {
+        this.age = age;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    @BuilderProperty
+    public void setName(String name) {
+        this.name = name;
+    }
+
+}

annotations/annotation-user/src/test/java/com/baeldung/annotation/PersonBuilderTest.java

@@ -0,0 +1,22 @@
+package com.baeldung.annotation;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class PersonBuilderTest {
+
+    @Test
+    public void whenBuildPersonWithBuilder_thenObjectHasPropertyValues() {
+
+        Person person = new PersonBuilder()
+                .setAge(25)
+                .setName("John")
+                .build();
+
+        assertEquals(25, person.getAge());
+        assertEquals("John", person.getName());
+
+    }
+
+}

annotations/pom.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>parent-modules</artifactId>
+        <groupId>com.baeldung</groupId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>annotations</artifactId>
+    <packaging>pom</packaging>
+
+    <modules>
+        <module>annotation-processing</module>
+        <module>annotation-user</module>
+    </modules>
+
+</project>

autovalue-tutorial/pom.xml

@@ -1,36 +1,37 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-	<modelVersion>4.0.0</modelVersion>
-	<groupId>com.baeldung</groupId>
-	<artifactId>autovalue-tutorial</artifactId>
-	<version>1.0</version>
-	<name>AutoValue</name>
-   <build>
-    <plugins>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-compiler-plugin</artifactId>
-        <version>3.3</version>
-        <configuration>
-          <source>7</source>
-          <target>7</target>
-        </configuration>
-      </plugin>
-    </plugins>
-  </build>
-	<dependencies>
-<dependency>
-    <groupId>com.google.auto.value</groupId>
-    <artifactId>auto-value</artifactId>
-    <version>1.2</version>
-</dependency>
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.baeldung</groupId>
+    <artifactId>autovalue-tutorial</artifactId>
+    <version>1.0</version>
+    <name>AutoValue</name>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.3</version>
+                <configuration>
+                    <source>7</source>
+                    <target>7</target>
+                    <useIncrementalCompilation>false</useIncrementalCompilation>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+    <dependencies>
+        <dependency>
+            <groupId>com.google.auto.value</groupId>
+            <artifactId>auto-value</artifactId>
+            <version>1.2</version>
+        </dependency>
 
-		<dependency>
-			<groupId>junit</groupId>
-			<artifactId>junit</artifactId>
-			<version>4.3</version>
-			<scope>test</scope>
-		</dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.3</version>
+            <scope>test</scope>
+        </dependency>
 
-	</dependencies>
+    </dependencies>
 </project>

cdi/pom.xml

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.baeldung</groupId>
+    <artifactId>cdi</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-core</artifactId>
+            <version>${spring.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+            <version>${spring.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.aspectj</groupId>
+            <artifactId>aspectjweaver</artifactId>
+            <version>1.8.9</version>
+        </dependency>
+        <dependency>
+            <groupId>org.jboss.weld.se</groupId>
+            <artifactId>weld-se-core</artifactId>
+            <version>2.3.5.Final</version>
+        </dependency>
+
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+            <version>${spring.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+    </dependencies>
+
+    <properties>
+        <spring.version>4.3.1.RELEASE</spring.version>
+    </properties>
+
+</project>

cdi/src/main/java/com/baeldung/interceptor/Audited.java

@@ -0,0 +1,14 @@
+package com.baeldung.interceptor;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import javax.interceptor.InterceptorBinding;
+
+@InterceptorBinding
+@Target({ ElementType.METHOD, ElementType.TYPE })
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Audited {
+}

cdi/src/main/java/com/baeldung/interceptor/AuditedInterceptor.java

@@ -0,0 +1,20 @@
+package com.baeldung.interceptor;
+
+import javax.interceptor.AroundInvoke;
+import javax.interceptor.Interceptor;
+import javax.interceptor.InvocationContext;
+
+@Audited
+@Interceptor
+public class AuditedInterceptor {
+    public static boolean calledBefore = false;
+    public static boolean calledAfter = false;
+
+    @AroundInvoke
+    public Object auditMethod(InvocationContext ctx) throws Exception {
+        calledBefore = true;
+        Object result = ctx.proceed();
+        calledAfter = true;
+        return result;
+    }
+}

cdi/src/main/java/com/baeldung/service/SuperService.java

@@ -0,0 +1,10 @@
+package com.baeldung.service;
+
+import com.baeldung.interceptor.Audited;
+
+public class SuperService {
+    @Audited
+    public String deliverService(String uid) {
+        return uid;
+    }
+}

cdi/src/main/java/com/baeldung/spring/aspect/SpringTestAspect.java

@@ -0,0 +1,23 @@
+package com.baeldung.spring.aspect;
+
+import java.util.List;
+
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.springframework.beans.factory.annotation.Autowired;
+
+@Aspect
+public class SpringTestAspect {
+    @Autowired
+    private List<String> accumulator;
+
+    @Around("execution(* com.baeldung.spring.service.SpringSuperService.*(..))")
+    public Object auditMethod(ProceedingJoinPoint jp) throws Throwable {
+        String methodName = jp.getSignature().getName();
+        accumulator.add("Call to " + methodName);
+        Object obj = jp.proceed();
+        accumulator.add("Method called successfully: " + methodName);
+        return obj;
+    }
+}

cdi/src/main/java/com/baeldung/spring/configuration/AppConfig.java

@@ -0,0 +1,30 @@
+package com.baeldung.spring.configuration;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.EnableAspectJAutoProxy;
+
+import com.baeldung.spring.aspect.SpringTestAspect;
+import com.baeldung.spring.service.SpringSuperService;
+
+@Configuration
+@EnableAspectJAutoProxy
+public class AppConfig {
+    @Bean
+    public SpringSuperService springSuperService() {
+        return new SpringSuperService();
+    }
+
+    @Bean
+    public SpringTestAspect springTestAspect() {
+        return new SpringTestAspect();
+    }
+
+    @Bean
+    public List<String> getAccumulator() {
+        return new ArrayList<String>();
+    }
+}

cdi/src/main/java/com/baeldung/spring/service/SpringSuperService.java

@@ -0,0 +1,7 @@
+package com.baeldung.spring.service;
+
+public class SpringSuperService {
+    public String getInfoFromService(String code) {
+        return code;
+    }
+}

cdi/src/main/resources/META-INF/beans.xml

@@ -0,0 +1,8 @@
+<beans xmlns="http://java.sun.com/xml/ns/javaee"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
+      http://java.sun.com/xml/ns/javaee/beans_1_2.xsd">
+    <interceptors>
+        <class>com.baeldung.interceptor.AuditedInterceptor</class>
+    </interceptors>
+</beans>

cdi/src/test/java/com/baeldung/test/TestInterceptor.java

@@ -0,0 +1,38 @@
+package com.baeldung.test;
+
+import org.jboss.weld.environment.se.Weld;
+import org.jboss.weld.environment.se.WeldContainer;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.baeldung.interceptor.AuditedInterceptor;
+import com.baeldung.service.SuperService;
+
+public class TestInterceptor {
+    Weld weld;
+    WeldContainer container;
+
+    @Before
+    public void init() {
+        weld = new Weld();
+        container = weld.initialize();
+    }
+
+    @After
+    public void shutdown() {
+        weld.shutdown();
+    }
+
+    @Test
+    public void givenTheService_whenMethodAndInterceptorExecuted_thenOK() {
+        SuperService superService = container.select(SuperService.class).get();
+        String code = "123456";
+        superService.deliverService(code);
+
+        Assert.assertTrue(AuditedInterceptor.calledBefore);
+        Assert.assertTrue(AuditedInterceptor.calledAfter);
+    }
+
+}

cdi/src/test/java/com/baeldung/test/TestSpringInterceptor.java

@@ -0,0 +1,34 @@
+package com.baeldung.test;
+
+import static org.hamcrest.CoreMatchers.is;
+
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.spring.configuration.AppConfig;
+import com.baeldung.spring.service.SpringSuperService;
+
+@RunWith(SpringRunner.class)
+@ContextConfiguration(classes = { AppConfig.class })
+public class TestSpringInterceptor {
+    @Autowired
+    SpringSuperService springSuperService;
+
+    @Autowired
+    private List<String> accumulator;
+
+    @Test
+    public void givenService_whenServiceAndAspectExecuted_thenOk() {
+        String code = "123456";
+        String result = springSuperService.getInfoFromService(code);
+        Assert.assertThat(accumulator.size(), is(2));
+        Assert.assertThat(accumulator.get(0), is("Call to getInfoFromService"));
+        Assert.assertThat(accumulator.get(1), is("Method called successfully: getInfoFromService"));
+    }
+}

core-java-8/README.md

@@ -11,4 +11,14 @@
 - [Lambda Expressions and Functional Interfaces: Tips and Best Practices](http://www.baeldung.com/java-8-lambda-expressions-tips)
 - [The Double Colon Operator in Java 8](http://www.baeldung.com/java-8-double-colon-operator)
 - [Java 8 Streams Advanced](http://www.baeldung.com/java-8-streams)
-- [Java 8 Collectors](http://www.baeldung.com/java-8-collectors)
+- [Java 8 Collectors](http://www.baeldung.com/java-8-collectors)
+- [Convert String to int or Integer in Java](http://www.baeldung.com/java-convert-string-to-int-or-integer)
+- [Convert char to String in Java](http://www.baeldung.com/java-convert-char-to-string)
+- [Guide to Java 8’s Functional Interfaces](http://www.baeldung.com/java-8-functional-interfaces)
+- [Guide To CompletableFuture](http://www.baeldung.com/java-completablefuture)
+- [Introduction to Thread Pools in Java](http://www.baeldung.com/thread-pool-java-and-guava)
+- [Guide to Java 8 Collectors](http://www.baeldung.com/java-8-collectors)
+- [The Java 8 Stream API Tutorial](http://www.baeldung.com/java-8-streams)
+- [New Features in Java 8](http://www.baeldung.com/java-8-new-features)
+- [Introduction to Java 8 Streams](http://www.baeldung.com/java-8-streams-introduction)
+- [Guide to the Fork/Join Framework in Java](http://www.baeldung.com/java-fork-join)

core-java-8/pom.xml

@@ -1,9 +1,10 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
+
     <groupId>com.baeldung</groupId>
+    <version>1.0.0-SNAPSHOT</version>
     <artifactId>core-java8</artifactId>
-    <version>0.1-SNAPSHOT</version>
 
     <name>core-java8</name>
 
@@ -111,6 +112,9 @@
     </build>
 
     <properties>
+
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+
         <!-- logging -->
         <org.slf4j.version>1.7.13</org.slf4j.version>
         <logback.version>1.0.13</logback.version>

core-java-8/src/main/java/com/baeldung/threadpool/CountingTask.java

@@ -0,0 +1,22 @@
+package com.baeldung.threadpool;
+
+import java.util.concurrent.ForkJoinTask;
+import java.util.concurrent.RecursiveTask;
+import java.util.stream.Collectors;
+
+public class CountingTask extends RecursiveTask<Integer> {
+
+    private final TreeNode node;
+
+    public CountingTask(TreeNode node) {
+        this.node = node;
+    }
+
+    @Override
+    protected Integer compute() {
+        return node.value + node.children.stream()
+                .map(childNode -> new CountingTask(childNode).fork())
+                .collect(Collectors.summingInt(ForkJoinTask::join));
+    }
+
+}

core-java-8/src/main/java/com/baeldung/threadpool/ExitingExecutorServiceExample.java

@@ -0,0 +1,29 @@
+package com.baeldung.threadpool;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+import com.google.common.util.concurrent.MoreExecutors;
+
+/**
+ * This class demonstrates the usage of Guava's exiting executor services that keep the VM from hanging.
+ * Without the exiting executor service, the task would hang indefinitely.
+ * This behaviour cannot be demonstrated in JUnit tests, as JUnit kills the VM after the tests.
+ */
+public class ExitingExecutorServiceExample {
+
+    public static void main(String... args) {
+
+        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(5);
+        ExecutorService executorService = MoreExecutors.getExitingExecutorService(executor, 100, TimeUnit.MILLISECONDS);
+
+        executorService.submit(() -> {
+            while (true) {
+            }
+        });
+
+    }
+
+}

core-java-8/src/main/java/com/baeldung/threadpool/TreeNode.java

@@ -0,0 +1,18 @@
+package com.baeldung.threadpool;
+
+import java.util.Set;
+
+import com.google.common.collect.Sets;
+
+public class TreeNode {
+
+    int value;
+
+    Set<TreeNode> children;
+
+    public TreeNode(int value, TreeNode... children) {
+        this.value = value;
+        this.children = Sets.newHashSet(children);
+    }
+
+}

core-java-8/src/main/resources/fileTest.txt

@@ -0,0 +1 @@
+Hello World from fileTest.txt!!!

core-java-8/src/test/java/com/baeldung/CharToStringTest.java

@@ -0,0 +1,53 @@
+package com.baeldung;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class CharToStringTest {
+
+    @Test
+    public void givenChar_whenCallingStringValueOf_shouldConvertToString(){
+        final char givenChar = 'x';
+
+        final String result = String.valueOf(givenChar);
+
+        assertThat(result).isEqualTo("x");
+    }
+
+    @Test
+    public void givenChar_whenCallingToStringOnCharacter_shouldConvertToString(){
+        final char givenChar = 'x';
+
+        final String result = Character.toString(givenChar);
+
+        assertThat(result).isEqualTo("x");
+    }
+
+    @Test
+    public void givenChar_whenCallingCharacterConstructor_shouldConvertToString3(){
+        final char givenChar = 'x';
+
+        final String result = new Character(givenChar).toString();
+
+        assertThat(result).isEqualTo("x");
+    }
+
+    @Test
+    public void givenChar_whenConcatenated_shouldConvertToString4(){
+        final char givenChar = 'x';
+
+        final String result = givenChar + "";
+
+        assertThat(result).isEqualTo("x");
+    }
+
+    @Test
+    public void givenChar_whenFormated_shouldConvertToString5(){
+        final char givenChar = 'x';
+
+        final String result = String.format("%c", givenChar);
+
+        assertThat(result).isEqualTo("x");
+    }
+}

core-java-8/src/test/java/com/baeldung/RandomListElementTest.java

@@ -0,0 +1,17 @@
+package com.baeldung;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+
+public class RandomListElementTest {
+
+    @Test
+    public void givenList_whenRandomNumberChosen_shouldReturnARandomElement() {
+        List<Integer> givenList = Arrays.asList(1, 2, 3);
+        Random rand = new Random();
+        givenList.get(rand.nextInt(givenList.size()));
+    }
+}

core-java-8/src/test/java/com/baeldung/StringToIntOrIntegerTest.java

@@ -0,0 +1,62 @@
+package com.baeldung;
+
+import com.google.common.primitives.Ints;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class StringToIntOrIntegerTest {
+
+    @Test
+    public void givenString_whenParsingInt_shouldConvertToInt() {
+        String givenString = "42";
+
+        int result = Integer.parseInt(givenString);
+
+        assertThat(result).isEqualTo(42);
+    }
+
+
+    @Test
+    public void givenString_whenCallingIntegerValueOf_shouldConvertToInt() {
+        String givenString = "42";
+
+        Integer result = Integer.valueOf(givenString);
+
+        assertThat(result).isEqualTo(new Integer(42));
+    }
+
+    @Test
+    public void givenString_whenCallingIntegerConstructor_shouldConvertToInt() {
+        String givenString = "42";
+
+        Integer result = new Integer(givenString);
+
+        assertThat(result).isEqualTo(new Integer(42));
+    }
+
+    @Test
+    public void givenString_whenCallingIntegerDecode_shouldConvertToInt() {
+        String givenString = "42";
+
+        int result = Integer.decode(givenString);
+
+        assertThat(result).isEqualTo(42);
+    }
+
+    @Test
+    public void givenString_whenTryParse_shouldConvertToInt() {
+        String givenString = "42";
+
+        Integer result = Ints.tryParse(givenString);
+
+        assertThat(result).isEqualTo(42);
+    }
+
+    @Test(expected = NumberFormatException.class)
+    public void givenInvalidInput_whenParsingInt_shouldThrow() {
+        String givenString = "nan";
+        Integer.parseInt(givenString);
+    }
+
+}

core-java-8/src/test/java/com/baeldung/completablefuture/CompletableFutureTest.java

@@ -0,0 +1,209 @@
+package com.baeldung.completablefuture;
+
+import java.util.concurrent.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class CompletableFutureTest {
+
+    @Test
+    public void whenRunningCompletableFutureAsynchronously_thenGetMethodWaitsForResult() throws InterruptedException, ExecutionException {
+
+        Future<String> completableFuture = calculateAsync();
+
+        String result = completableFuture.get();
+        assertEquals("Hello", result);
+
+    }
+
+    public Future<String> calculateAsync() throws InterruptedException {
+        CompletableFuture<String> completableFuture = new CompletableFuture<>();
+
+        Executors.newCachedThreadPool().submit(() -> {
+            Thread.sleep(500);
+            completableFuture.complete("Hello");
+            return null;
+        });
+
+        return completableFuture;
+    }
+
+    @Test
+    public void whenRunningCompletableFutureWithResult_thenGetMethodReturnsImmediately() throws InterruptedException, ExecutionException {
+
+        Future<String> completableFuture = CompletableFuture.completedFuture("Hello");
+
+        String result = completableFuture.get();
+        assertEquals("Hello", result);
+
+    }
+
+
+    public Future<String> calculateAsyncWithCancellation() throws InterruptedException {
+        CompletableFuture<String> completableFuture = new CompletableFuture<>();
+
+        Executors.newCachedThreadPool().submit(() -> {
+            Thread.sleep(500);
+            completableFuture.cancel(false);
+            return null;
+        });
+
+        return completableFuture;
+    }
+
+
+    @Test(expected = CancellationException.class)
+    public void whenCancelingTheFuture_thenThrowsCancellationException() throws ExecutionException, InterruptedException {
+
+        Future<String> future = calculateAsyncWithCancellation();
+        future.get();
+
+    }
+
+    @Test
+    public void whenCreatingCompletableFutureWithSupplyAsync_thenFutureReturnsValue() throws ExecutionException, InterruptedException {
+
+        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");
+
+        assertEquals("Hello", future.get());
+
+    }
+
+    @Test
+    public void whenAddingThenAcceptToFuture_thenFunctionExecutesAfterComputationIsFinished() throws ExecutionException, InterruptedException {
+
+        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "Hello");
+
+        CompletableFuture<Void> future = completableFuture.thenAccept(s -> System.out.println("Computation returned: " + s));
+
+        future.get();
+
+    }
+
+    @Test
+    public void whenAddingThenRunToFuture_thenFunctionExecutesAfterComputationIsFinished() throws ExecutionException, InterruptedException {
+
+        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "Hello");
+
+        CompletableFuture<Void> future = completableFuture.thenRun(() -> System.out.println("Computation finished."));
+
+        future.get();
+
+    }
+
+    @Test
+    public void whenAddingThenApplyToFuture_thenFunctionExecutesAfterComputationIsFinished() throws ExecutionException, InterruptedException {
+
+        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "Hello");
+
+        CompletableFuture<String> future = completableFuture.thenApply(s -> s + " World");
+
+        assertEquals("Hello World", future.get());
+
+    }
+
+    @Test
+    public void whenUsingThenCompose_thenFuturesExecuteSequentially() throws ExecutionException, InterruptedException {
+
+        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "Hello")
+                .thenCompose(s -> CompletableFuture.supplyAsync(() -> s + " World"));
+
+        assertEquals("Hello World", completableFuture.get());
+
+    }
+
+    @Test
+    public void whenUsingThenCombine_thenWaitForExecutionOfBothFutures() throws ExecutionException, InterruptedException {
+
+        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "Hello")
+                .thenCombine(CompletableFuture.supplyAsync(() -> " World"),
+                        (s1, s2) -> s1 + s2);
+
+        assertEquals("Hello World", completableFuture.get());
+
+    }
+
+    @Test
+    public void whenUsingThenAcceptBoth_thenWaitForExecutionOfBothFutures() throws ExecutionException, InterruptedException {
+
+        CompletableFuture.supplyAsync(() -> "Hello")
+                .thenAcceptBoth(CompletableFuture.supplyAsync(() -> " World"),
+                        (s1, s2) -> System.out.println(s1 + s2));
+
+    }
+
+    @Test
+    public void whenFutureCombinedWithAllOfCompletes_thenAllFuturesAreDone() throws ExecutionException, InterruptedException {
+
+        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
+        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "Beautiful");
+        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> "World");
+
+        CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(future1, future2, future3);
+
+        // ...
+
+        combinedFuture.get();
+
+        assertTrue(future1.isDone());
+        assertTrue(future2.isDone());
+        assertTrue(future3.isDone());
+
+        String combined = Stream.of(future1, future2, future3)
+                .map(CompletableFuture::join)
+                .collect(Collectors.joining(" "));
+
+        assertEquals("Hello Beautiful World", combined);
+
+    }
+
+    @Test
+    public void whenFutureThrows_thenHandleMethodReceivesException() throws ExecutionException, InterruptedException {
+
+        String name = null;
+
+        // ...
+
+        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
+            if (name == null) {
+                throw new RuntimeException("Computation error!");
+            }
+            return "Hello, " + name;
+        }).handle((s, t) -> s != null ? s : "Hello, Stranger!");
+
+        assertEquals("Hello, Stranger!", completableFuture.get());
+
+    }
+
+    @Test(expected = ExecutionException.class)
+    public void whenCompletingFutureExceptionally_thenGetMethodThrows() throws ExecutionException, InterruptedException {
+
+        CompletableFuture<String> completableFuture = new CompletableFuture<>();
+
+        // ...
+
+        completableFuture.completeExceptionally(new RuntimeException("Calculation failed!"));
+
+        // ...
+
+        completableFuture.get();
+
+    }
+
+    @Test
+    public void whenAddingThenApplyAsyncToFuture_thenFunctionExecutesAfterComputationIsFinished() throws ExecutionException, InterruptedException {
+
+        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "Hello");
+
+        CompletableFuture<String> future = completableFuture.thenApplyAsync(s -> s + " World");
+
+        assertEquals("Hello World", future.get());
+
+    }
+
+}

core-java-8/src/test/java/com/baeldung/file/FileOperationsTest.java

@@ -0,0 +1,78 @@
+package com.baeldung.file;
+
+import org.hamcrest.Matchers;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.net.URLConnection;
+
+import static org.hamcrest.CoreMatchers.containsString;
+
+public class FileOperationsTest {
+
+    @Test
+    public void givenFileName_whenUsingClassloader_thenFileData() throws IOException {
+        String expectedData = "Hello World from fileTest.txt!!!";
+
+        ClassLoader classLoader = getClass().getClassLoader();
+        InputStream inputStream = classLoader.getResourceAsStream("fileTest.txt");
+        String data = readFromInputStream(inputStream);
+
+        Assert.assertThat(data, containsString(expectedData));
+}
+
+    @Test
+    public void givenFileNameAsAbsolutePath_whenUsingClasspath_thenFileData() throws IOException {
+        String expectedData = "Hello World from fileTest.txt!!!";
+
+        Class clazz = FileOperationsTest.class;
+        InputStream inputStream = clazz.getResourceAsStream("/fileTest.txt");
+        String data = readFromInputStream(inputStream);
+
+        Assert.assertThat(data, containsString(expectedData));
+    }
+
+    @Test
+    public void givenURLName_whenUsingURL_thenFileData() throws IOException {
+        String expectedData = "Baeldung";
+
+        URL urlObject = new URL("http://www.baeldung.com/");
+        URLConnection urlConnection = urlObject.openConnection();
+
+        InputStream inputStream = urlConnection.getInputStream();
+        String data = readFromInputStream(inputStream);
+
+        Assert.assertThat(data, containsString(expectedData));
+    }
+
+    @Test
+    public void givenFileName_whenUsingJarFile_thenFileData() throws IOException {
+        String expectedData = "BSD License";
+
+        Class clazz = Matchers.class;
+        InputStream inputStream = clazz.getResourceAsStream("/LICENSE.txt");
+        String data = readFromInputStream(inputStream);
+
+        Assert.assertThat(data, containsString(expectedData));
+    }
+
+    private String readFromInputStream(InputStream inputStream) throws IOException {
+        InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
+        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
+        StringBuilder resultStringBuilder = new StringBuilder();
+        String line;
+        while ((line = bufferedReader.readLine()) != null) {
+            resultStringBuilder.append(line);
+            resultStringBuilder.append("\n");
+        }
+        bufferedReader.close();
+        inputStreamReader.close();
+        inputStream.close();
+        return resultStringBuilder.toString();
+    }
+}