Merge remote-tracking branch 'upstream/master'

algorithms-miscellaneous-1/src/main/java/com/baeldung/algorithms/enumstatemachine/LeaveRequestState.java

@@ -0,0 +1,46 @@
+package com.baeldung.algorithms.enumstatemachine;
+
+public enum LeaveRequestState {
+
+    Submitted {
+        @Override
+        public LeaveRequestState nextState() {
+            System.out.println("Starting the Leave Request and sending to Team Leader for approval.");
+            return Escalated;
+        }
+
+        @Override
+        public String responsiblePerson() {
+            return "Employee";
+        }
+    },
+    Escalated {
+        @Override
+        public LeaveRequestState nextState() {
+            System.out.println("Reviewing the Leave Request and escalating to Department Manager.");
+            return Approved;
+        }
+
+        @Override
+        public String responsiblePerson() {
+            return "Team Leader";
+        }
+    },
+    Approved {
+        @Override
+        public LeaveRequestState nextState() {
+            System.out.println("Approving the Leave Request.");
+            return this;
+        }
+
+        @Override
+        public String responsiblePerson() {
+            return "Department Manager";
+        }
+    };
+
+    public abstract String responsiblePerson();
+
+    public abstract LeaveRequestState nextState();
+
+}

algorithms-miscellaneous-1/src/test/java/com/baeldung/algorithms/enumstatemachine/LeaveRequestStateUnitTest.java

@@ -0,0 +1,37 @@
+package com.baeldung.algorithms.enumstatemachine;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class LeaveRequestStateUnitTest {
+
+    @Test
+    public void givenLeaveRequest_whenStateEscalated_thenResponsibleIsTeamLeader() {
+        LeaveRequestState state = LeaveRequestState.Escalated;
+
+        assertEquals(state.responsiblePerson(), "Team Leader");
+    }
+
+
+    @Test
+    public void givenLeaveRequest_whenStateApproved_thenResponsibleIsDepartmentManager() {
+        LeaveRequestState state = LeaveRequestState.Approved;
+
+        assertEquals(state.responsiblePerson(), "Department Manager");
+    }
+
+    @Test
+    public void givenLeaveRequest_whenNextStateIsCalled_thenStateIsChanged() {
+        LeaveRequestState state = LeaveRequestState.Submitted;
+
+        state = state.nextState();
+        assertEquals(state, LeaveRequestState.Escalated);
+
+        state = state.nextState();
+        assertEquals(state, LeaveRequestState.Approved);
+
+        state = state.nextState();
+        assertEquals(state, LeaveRequestState.Approved);
+    }
+}

blade/README.md

@@ -0,0 +1,5 @@
+### Relevant Articles: 
+
+- [Blade - A Complete GuideBook](http://www.baeldung.com/blade) 
+
+Run Integration Tests with `mvn integration-test`

blade/pom.xml

@@ -0,0 +1,189 @@
+<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>
+    <artifactId>blade</artifactId>
+    <name>blade</name>
+
+    <!-- WITH THIS mvn integration-test DOES WORK -->
+    <groupId>com.baeldung</groupId>
+    <version>1.0.0-SNAPSHOT</version>
+
+    <!-- WITH THIS mvn integration-test DOESN'T WORK -->
+    <!-- <parent> -->
+    <!-- <groupId>com.baeldung</groupId> -->
+    <!-- <artifactId>parent-modules</artifactId> -->
+    <!-- <version>1.0.0-SNAPSHOT</version> -->
+    <!-- </parent> -->
+
+    <properties>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.bladejava</groupId>
+            <artifactId>blade-mvc</artifactId>
+            <version>2.0.14.RELEASE</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.webjars</groupId>
+            <artifactId>bootstrap</artifactId>
+            <version>4.2.1</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>3.8.1</version>
+        </dependency>
+
+        <!-- PROVIDED -->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.4</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <!-- TEST -->
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>3.11.1</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpclient</artifactId>
+            <version>4.5.6</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpmime</artifactId>
+            <version>4.5.6</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpcore</artifactId>
+            <version>4.4.10</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+    <build>
+        <finalName>sample-blade-app</finalName>
+        <plugins>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <forkCount>3</forkCount>
+                    <reuseForks>true</reuseForks>
+                    <excludes>
+                        <exclude>**/*LiveTest.java</exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-failsafe-plugin</artifactId>
+                <version>3.0.0-M3</version>
+                <configuration>
+                    <includes>
+                        <include>**/*LiveTest.java</include>
+                    </includes>
+                </configuration>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>integration-test</goal>
+                            <goal>verify</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+
+            <plugin>
+                <groupId>com.bazaarvoice.maven.plugins</groupId>
+                <artifactId>process-exec-maven-plugin</artifactId>
+                <version>0.7</version>
+                <executions>
+                    <!--Start Blade -->
+                    <execution>
+                        <id>blade-process</id>
+                        <phase>pre-integration-test</phase>
+                        <goals>
+                            <goal>start</goal>
+                        </goals>
+                        <configuration>
+                            <name>Blade</name>
+                            <waitForInterrupt>false</waitForInterrupt>
+                            <arguments>
+                                <argument>java</argument>
+                                <argument>-jar</argument>
+                                <argument>sample-blade-app.jar</argument>
+                            </arguments>
+                        </configuration>
+                    </execution>
+
+                    <!--Stop all processes in reverse order -->
+                    <execution>
+                        <id>stop-all</id>
+                        <phase>post-integration-test</phase>
+                        <goals>
+                            <goal>stop-all</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+
+
+            <plugin>
+                <artifactId>maven-assembly-plugin</artifactId>
+                <version>3.1.0</version>
+                <configuration>
+                    <finalName>${project.build.finalName}</finalName>
+                    <appendAssemblyId>false</appendAssemblyId>
+                    <archive>
+                        <manifest>
+                            <mainClass>com.baeldung.blade.sample.App</mainClass>
+                        </manifest>
+                    </archive>
+                    <descriptorRefs>
+                        <descriptorRef>jar-with-dependencies</descriptorRef>
+                    </descriptorRefs>
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>make-assembly</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>single</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                    <encoding>UTF-8</encoding>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

blade/src/main/java/com/baeldung/blade/sample/App.java

@@ -0,0 +1,38 @@
+package com.baeldung.blade.sample;
+
+import com.baeldung.blade.sample.interceptors.BaeldungMiddleware;
+import com.blade.Blade;
+import com.blade.event.EventType;
+import com.blade.mvc.WebContext;
+import com.blade.mvc.http.Session;
+
+public class App {
+
+    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(App.class);
+
+    public static void main(String[] args) {
+
+        Blade.of()
+            .get("/", ctx -> ctx.render("index.html"))
+            .get("/basic-route-example", ctx -> ctx.text("GET called"))
+            .post("/basic-route-example", ctx -> ctx.text("POST called"))
+            .put("/basic-route-example", ctx -> ctx.text("PUT called"))
+            .delete("/basic-route-example", ctx -> ctx.text("DELETE called"))
+            .addStatics("/custom-static")
+            // .showFileList(true)
+            .enableCors(true)
+            .before("/user/*", ctx -> log.info("[NarrowedHook] Before '/user/*', URL called: " + ctx.uri()))
+            .on(EventType.SERVER_STARTED, e -> {
+                String version = WebContext.blade()
+                    .env("app.version")
+                    .orElse("N/D");
+                log.info("[Event::serverStarted] Loading 'app.version' from configuration, value: " + version);
+            })
+            .on(EventType.SESSION_CREATED, e -> {
+                Session session = (Session) e.attribute("session");
+                session.attribute("mySessionValue", "Baeldung");
+            })
+            .use(new BaeldungMiddleware())
+            .start(App.class, args);
+    }
+}

blade/src/main/java/com/baeldung/blade/sample/AttributesExampleController.java

@@ -0,0 +1,37 @@
+package com.baeldung.blade.sample;
+
+import com.blade.mvc.annotation.GetRoute;
+import com.blade.mvc.annotation.Path;
+import com.blade.mvc.http.Request;
+import com.blade.mvc.http.Response;
+import com.blade.mvc.http.Session;
+
+@Path
+public class AttributesExampleController {
+
+    public final static String REQUEST_VALUE = "Some Request value";
+    public final static String SESSION_VALUE = "1337";
+    public final static String HEADER = "Some Header";
+
+    @GetRoute("/request-attribute-example")
+    public void getRequestAttribute(Request request, Response response) {
+        request.attribute("request-val", REQUEST_VALUE);
+        String requestVal = request.attribute("request-val");
+        response.text(requestVal);
+    }
+
+    @GetRoute("/session-attribute-example")
+    public void getSessionAttribute(Request request, Response response) {
+        Session session = request.session();
+        session.attribute("session-val", SESSION_VALUE);
+        String sessionVal = session.attribute("session-val");
+        response.text(sessionVal);
+    }
+
+    @GetRoute("/header-example")
+    public void getHeader(Request request, Response response) {
+        String headerVal = request.header("a-header", HEADER);
+        response.header("a-header", headerVal);
+    }
+
+}

blade/src/main/java/com/baeldung/blade/sample/LogExampleController.java

@@ -0,0 +1,22 @@
+package com.baeldung.blade.sample;
+
+import com.blade.mvc.annotation.Path;
+import com.blade.mvc.annotation.Route;
+import com.blade.mvc.http.Response;
+
+@Path
+public class LogExampleController {
+
+    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LogExampleController.class);
+
+    @Route(value = "/test-logs")
+    public void testLogs(Response response) {
+        log.trace("This is a TRACE Message");
+        log.debug("This is a DEBUG Message");
+        log.info("This is an INFO Message");
+        log.warn("This is a WARN Message");
+        log.error("This is an ERROR Message");
+        response.text("Check in ./logs");
+    }
+
+}

blade/src/main/java/com/baeldung/blade/sample/ParameterInjectionExampleController.java

@@ -0,0 +1,71 @@
+package com.baeldung.blade.sample;
+
+import java.nio.file.Files;
+import java.nio.file.StandardOpenOption;
+
+import com.baeldung.blade.sample.vo.User;
+import com.blade.mvc.annotation.CookieParam;
+import com.blade.mvc.annotation.GetRoute;
+import com.blade.mvc.annotation.HeaderParam;
+import com.blade.mvc.annotation.JSON;
+import com.blade.mvc.annotation.MultipartParam;
+import com.blade.mvc.annotation.Param;
+import com.blade.mvc.annotation.Path;
+import com.blade.mvc.annotation.PathParam;
+import com.blade.mvc.annotation.PostRoute;
+import com.blade.mvc.http.Response;
+import com.blade.mvc.multipart.FileItem;
+import com.blade.mvc.ui.RestResponse;
+
+@Path
+public class ParameterInjectionExampleController {
+
+    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(ParameterInjectionExampleController.class);
+
+    @GetRoute("/params/form")
+    public void formParam(@Param String name, Response response) {
+        log.info("name: " + name);
+        response.text(name);
+    }
+
+    @GetRoute("/params/path/:uid")
+    public void restfulParam(@PathParam Integer uid, Response response) {
+        log.info("uid: " + uid);
+        response.text(String.valueOf(uid));
+    }
+
+    @PostRoute("/params-file") // DO NOT USE A SLASH WITHIN THE ROUTE OR IT WILL BREAK (?)
+    @JSON
+    public RestResponse<?> fileParam(@MultipartParam FileItem fileItem) throws Exception {
+        try {
+            byte[] fileContent = fileItem.getData();
+
+            log.debug("Saving the uploaded file");
+            java.nio.file.Path tempFile = Files.createTempFile("baeldung_tempfiles", ".tmp");
+            Files.write(tempFile, fileContent, StandardOpenOption.WRITE);
+
+            return RestResponse.ok();
+        } catch (Exception e) {
+            log.error(e.getMessage(), e);
+            return RestResponse.fail(e.getMessage());
+        }
+    }
+
+    @GetRoute("/params/header")
+    public void headerParam(@HeaderParam String customheader, Response response) {
+        log.info("Custom header: " + customheader);
+        response.text(customheader);
+    }
+
+    @GetRoute("/params/cookie")
+    public void cookieParam(@CookieParam(defaultValue = "default value") String myCookie, Response response) {
+        log.info("myCookie: " + myCookie);
+        response.text(myCookie);
+    }
+
+    @PostRoute("/params/vo")
+    public void voParam(@Param User user, Response response) {
+        log.info("user as voParam: " + user.toString());
+        response.html(user.toString() + "<br/><br/><a href='/'>Back</a>");
+    }
+}

blade/src/main/java/com/baeldung/blade/sample/RouteExampleController.java

@@ -0,0 +1,78 @@
+package com.baeldung.blade.sample;
+
+import com.baeldung.blade.sample.configuration.BaeldungException;
+import com.blade.mvc.WebContext;
+import com.blade.mvc.annotation.DeleteRoute;
+import com.blade.mvc.annotation.GetRoute;
+import com.blade.mvc.annotation.Path;
+import com.blade.mvc.annotation.PostRoute;
+import com.blade.mvc.annotation.PutRoute;
+import com.blade.mvc.annotation.Route;
+import com.blade.mvc.http.HttpMethod;
+import com.blade.mvc.http.Request;
+import com.blade.mvc.http.Response;
+
+@Path
+public class RouteExampleController {
+
+    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(RouteExampleController.class);
+
+    @GetRoute("/route-example")
+    public String get() {
+        return "get.html";
+    }
+
+    @PostRoute("/route-example")
+    public String post() {
+        return "post.html";
+    }
+
+    @PutRoute("/route-example")
+    public String put() {
+        return "put.html";
+    }
+
+    @DeleteRoute("/route-example")
+    public String delete() {
+        return "delete.html";
+    }
+
+    @Route(value = "/another-route-example", method = HttpMethod.GET)
+    public String anotherGet() {
+        return "get.html";
+    }
+
+    @Route(value = "/allmatch-route-example")
+    public String allmatch() {
+        return "allmatch.html";
+    }
+
+    @Route(value = "/triggerInternalServerError")
+    public void triggerInternalServerError() {
+        int x = 1 / 0;
+    }
+
+    @Route(value = "/triggerBaeldungException")
+    public void triggerBaeldungException() throws BaeldungException {
+        throw new BaeldungException("Foobar Exception to threat differently");
+    }
+
+    @Route(value = "/user/foo")
+    public void urlCoveredByNarrowedWebhook(Response response) {
+        response.text("Check out for the WebHook covering '/user/*' in the logs");
+    }
+
+    @GetRoute("/load-configuration-in-a-route")
+    public void loadConfigurationInARoute(Response response) {
+        String authors = WebContext.blade()
+            .env("app.authors", "Unknown authors");
+        log.info("[/load-configuration-in-a-route] Loading 'app.authors' from configuration, value: " + authors);
+        response.render("index.html");
+    }
+
+    @GetRoute("/template-output-test")
+    public void templateOutputTest(Request request, Response response) {
+        request.attribute("name", "Blade");
+        response.render("template-output-test.html");
+    }
+}

blade/src/main/java/com/baeldung/blade/sample/configuration/BaeldungException.java

@@ -0,0 +1,9 @@
+package com.baeldung.blade.sample.configuration;
+
+public class BaeldungException extends RuntimeException {
+
+    public BaeldungException(String message) {
+        super(message);
+    }
+
+}

blade/src/main/java/com/baeldung/blade/sample/configuration/GlobalExceptionHandler.java

@@ -0,0 +1,25 @@
+package com.baeldung.blade.sample.configuration;
+
+import com.blade.ioc.annotation.Bean;
+import com.blade.mvc.WebContext;
+import com.blade.mvc.handler.DefaultExceptionHandler;
+
+@Bean
+public class GlobalExceptionHandler extends DefaultExceptionHandler {
+
+    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(GlobalExceptionHandler.class);
+
+    @Override
+    public void handle(Exception e) {
+        if (e instanceof BaeldungException) {
+            Exception baeldungException = (BaeldungException) e;
+            String msg = baeldungException.getMessage();
+            log.error("[GlobalExceptionHandler] Intercepted an exception to threat with additional logic. Error message: " + msg);
+            WebContext.response()
+                .render("index.html");
+
+        } else {
+            super.handle(e);
+        }
+    }
+}

blade/src/main/java/com/baeldung/blade/sample/configuration/LoadConfig.java

@@ -0,0 +1,23 @@
+package com.baeldung.blade.sample.configuration;
+
+import com.blade.Blade;
+import com.blade.ioc.annotation.Bean;
+import com.blade.loader.BladeLoader;
+import com.blade.mvc.WebContext;
+
+@Bean
+public class LoadConfig implements BladeLoader {
+
+    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoadConfig.class);
+
+    @Override
+    public void load(Blade blade) {
+        String version = WebContext.blade()
+            .env("app.version")
+            .orElse("N/D");
+        String authors = WebContext.blade()
+            .env("app.authors", "Unknown authors");
+
+        log.info("[LoadConfig] loaded 'app.version' (" + version + ") and 'app.authors' (" + authors + ") in a configuration bean");
+    }
+}

blade/src/main/java/com/baeldung/blade/sample/configuration/ScheduleExample.java

@@ -0,0 +1,15 @@
+package com.baeldung.blade.sample.configuration;
+
+import com.blade.ioc.annotation.Bean;
+import com.blade.task.annotation.Schedule;
+
+@Bean
+public class ScheduleExample {
+ 
+    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(ScheduleExample.class);
+    
+    @Schedule(name = "baeldungTask", cron = "0 */1 * * * ?")
+    public void runScheduledTask() {
+        log.info("[ScheduleExample] This is a scheduled Task running once per minute.");
+    }
+}

blade/src/main/java/com/baeldung/blade/sample/interceptors/BaeldungHook.java

@@ -0,0 +1,17 @@
+package com.baeldung.blade.sample.interceptors;
+
+import com.blade.ioc.annotation.Bean;
+import com.blade.mvc.RouteContext;
+import com.blade.mvc.hook.WebHook;
+
+@Bean
+public class BaeldungHook implements WebHook {
+
+    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(BaeldungHook.class);
+
+    @Override
+    public boolean before(RouteContext ctx) {
+        log.info("[BaeldungHook] called before Route method");
+        return true;
+    }
+}

blade/src/main/java/com/baeldung/blade/sample/interceptors/BaeldungMiddleware.java

@@ -0,0 +1,15 @@
+package com.baeldung.blade.sample.interceptors;
+
+import com.blade.mvc.RouteContext;
+import com.blade.mvc.hook.WebHook;
+
+public class BaeldungMiddleware implements WebHook {
+
+    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(BaeldungMiddleware.class);
+
+    @Override
+    public boolean before(RouteContext context) {
+        log.info("[BaeldungMiddleware] called before Route method and other WebHooks");
+        return true;
+    }
+}

blade/src/main/java/com/baeldung/blade/sample/vo/User.java

@@ -0,0 +1,16 @@
+package com.baeldung.blade.sample.vo;
+
+import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
+
+import lombok.Getter;
+import lombok.Setter;
+
+public class User {
+    @Getter @Setter private String name;    
+    @Getter @Setter private String site;
+    
+    @Override
+    public String toString() {
+        return ReflectionToStringBuilder.toString(this);
+    }
+}

blade/src/main/resources/application.properties

@@ -0,0 +1,5 @@
+mvc.statics.show-list=true
+mvc.view.404=my-404.html
+mvc.view.500=my-500.html
+app.version=0.0.1
+app.authors=Andrea Ligios

blade/src/main/resources/static/app.css

@@ -0,0 +1 @@
+/* App CSS */   

blade/src/main/resources/static/file-upload.html

@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<title>Title</title>
+<script src="https://cdn.staticfile.org/jquery/3.3.1/jquery.min.js"></script>
+</head>
+<body>
+
+
+    <h1>File Upload and download test</h1>
+    <form id="uploadForm" enctype="multipart/form-data">
+        <input id="file" type="file" name="file" />
+        <button id="upload" type="button">Upload</button>
+    </form>
+
+    <br />
+    <a href="/">Back</a>
+    <script>
+		var data = new FormData();
+
+		$('#upload').click(function() {
+			$.ajax({
+				url : '/params-file',
+				type : 'POST',
+				cache : false,
+				data : new FormData($('#uploadForm')[0]),
+				processData : false,
+				contentType : false
+			}).done(function(res) {
+				console.log(res);
+				if (res.success) {
+					alert('Ok');
+				} else {
+					alert(res.msg || 'Error');
+				}
+			}).fail(function(res) {
+			});
+		});
+	</script>
+
+</body>
+</html>

blade/src/main/resources/static/user-post.html

@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<title>Title</title>
+<script src="https://cdn.staticfile.org/jquery/3.3.1/jquery.min.js"></script>
+</head>
+<body>
+
+
+    <h1>User POJO post test</h1>
+    
+    
+    <form id="uploadForm" action="/params/vo" method="post">
+        <span>Person POJO:</span>
+        <input type="text" name="name" placeholder="name"/>
+        <input type="text" name="site" placeholder="site"/>
+        <button id="upload" type="submit">Send user object</button>
+    </form>
+
+    <br />
+    <a href="/">Back</a>
+
+</body>
+</html>

blade/src/main/resources/templates/allmatch.html

@@ -0,0 +1 @@
+ALLMATCH called

blade/src/main/resources/templates/delete.html

@@ -0,0 +1 @@
+DELETE called

blade/src/main/resources/templates/get.html

@@ -0,0 +1 @@
+GET called

blade/src/main/resources/templates/index.html

@@ -0,0 +1,30 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<title>Baeldung Blade App • Written by Andrea Ligios</title>
+<link href="/static/app.css" rel="stylesheet" />
+</head>
+<body>
+    <h1>Baeldung Blade App - Showcase</h1>
+
+    <h3>Manual tests</h3>
+    <p>The following are tests which are not covered by integration tests, but that can be run manually in order to check the functionality, either in the browser or in the logs, depending on the case.</p>
+
+    <ul>
+        <li><a href="/static/file-upload.html">File Upload</a></li>
+        <li><a href="/static/user-post.html">User POJO Post</a></li>
+        <li><a href="/user/foo">Webhook narrowed to the '/user/*' URL</a></li>
+        <li><a href="/load-configuration-in-a-route">Load Configuration in a Route</a></li>
+        <li><a href="/triggerInternalServerError">Trigger internal server error (and test the custom error 500 page)</a></li>
+        <li><a href="/triggerBaeldungException">Trigger BaeldungException (and test the Global Exception Handler)</a></li>
+    </ul>
+
+   
+    <h3>Session value created in App.java</h3>
+    <p>mySessionValue = ${mySessionValue}</p> 
+
+
+    <script src="/static/app.js"></script>
+</body>
+</html>

blade/src/main/resources/templates/my-404.html

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>404 Not found</title>
+  </head>
+  <body>
+    Custom Error 404 Page
+  </body>
+</html>

blade/src/main/resources/templates/my-500.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <title>500 Internal Server Error</title>
+    </head>
+    <body>
+        <h1> Custom Error 500 Page </h1>
+        <p> The following error occurred： "<strong>${message}</strong>"</p>
+        <pre> ${stackTrace} </pre>
+    </body>
+</html>

blade/src/main/resources/templates/post.html

@@ -0,0 +1 @@
+POST called

blade/src/main/resources/templates/put.html

@@ -0,0 +1 @@
+PUT called

blade/src/main/resources/templates/template-output-test.html

@@ -0,0 +1 @@
+<h1>Hello, ${name}!</h1>

blade/src/test/java/com/baeldung/blade/sample/AppLiveTest.java

@@ -0,0 +1,56 @@
+package com.baeldung.blade.sample;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpDelete;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.client.methods.HttpPut;
+import org.apache.http.client.methods.HttpUriRequest;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.util.EntityUtils;
+import org.junit.Test;
+
+public class AppLiveTest {
+
+    @Test
+    public void givenBasicRoute_whenGet_thenCorrectOutput() throws Exception {
+        final HttpUriRequest request = new HttpGet("http://localhost:9000/basic-route-example");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo("GET called");
+        }
+    }
+
+    @Test
+    public void givenBasicRoute_whenPost_thenCorrectOutput() throws Exception {
+        final HttpUriRequest request = new HttpPost("http://localhost:9000/basic-route-example");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo("POST called");
+        }
+    }
+
+    @Test
+    public void givenBasicRoute_whenPut_thenCorrectOutput() throws Exception {
+        final HttpUriRequest request = new HttpPut("http://localhost:9000/basic-route-example");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo("PUT called");
+        }
+    }
+
+    @Test
+    public void givenBasicRoute_whenDelete_thenCorrectOutput() throws Exception {
+        final HttpUriRequest request = new HttpDelete("http://localhost:9000/basic-route-example");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo("DELETE called");
+        }
+    }
+}

blade/src/test/java/com/baeldung/blade/sample/AttributesExampleControllerLiveTest.java

@@ -0,0 +1,55 @@
+package com.baeldung.blade.sample;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpUriRequest;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.util.EntityUtils;
+import org.junit.Test;
+
+public class AttributesExampleControllerLiveTest {
+
+    @Test
+    public void givenRequestAttribute_whenSet_thenRetrieveWithGet() throws Exception {
+        final HttpUriRequest request = new HttpGet("http://localhost:9000/request-attribute-example");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo(AttributesExampleController.REQUEST_VALUE);
+        }
+    }
+
+    @Test
+    public void givenSessionAttribute_whenSet_thenRetrieveWithGet() throws Exception {
+        final HttpUriRequest request = new HttpGet("http://localhost:9000/session-attribute-example");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo(AttributesExampleController.SESSION_VALUE);
+        }
+    }
+
+    @Test
+    public void givenHeader_whenSet_thenRetrieveWithGet() throws Exception {
+        final HttpUriRequest request = new HttpGet("http://localhost:9000/header-example");
+        request.addHeader("a-header","foobar");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(httpResponse.getHeaders("a-header")[0].getValue()).isEqualTo("foobar");
+        }
+    }
+
+    @Test
+    public void givenNoHeader_whenSet_thenRetrieveDefaultValueWithGet() throws Exception {
+        final HttpUriRequest request = new HttpGet("http://localhost:9000/header-example");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(httpResponse.getHeaders("a-header")[0].getValue()).isEqualTo(AttributesExampleController.HEADER);
+        }
+    }
+
+}

blade/src/test/java/com/baeldung/blade/sample/ParameterInjectionExampleControllerLiveTest.java

@@ -0,0 +1,82 @@
+package com.baeldung.blade.sample;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpUriRequest;
+import org.apache.http.client.utils.URIBuilder;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.util.EntityUtils;
+import org.junit.Test;
+
+public class ParameterInjectionExampleControllerLiveTest {
+
+    @Test
+    public void givenFormParam_whenSet_thenRetrieveWithGet() throws Exception {
+        URIBuilder builder = new URIBuilder("http://localhost:9000/params/form");
+        builder.setParameter("name", "Andrea Ligios");
+
+        final HttpUriRequest request = new HttpGet(builder.build());
+
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo("Andrea Ligios");
+        }
+    }
+
+    @Test
+    public void givenPathParam_whenSet_thenRetrieveWithGet() throws Exception {
+        final HttpUriRequest request = new HttpGet("http://localhost:9000/params/path/1337");
+
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo("1337");
+        }
+    }
+
+    // @Test
+    // public void givenFileParam_whenSet_thenRetrieveWithGet() throws Exception {
+    //
+    // byte[] data = "this is some temp file content".getBytes("UTF-8");
+    // java.nio.file.Path tempFile = Files.createTempFile("baeldung_test_tempfiles", ".tmp");
+    // Files.write(tempFile, data, StandardOpenOption.WRITE);
+    //
+    // //HttpEntity entity = MultipartEntityBuilder.create().addPart("file", new FileBody(tempFile.toFile())).build();
+    // HttpEntity entity = MultipartEntityBuilder.create().addTextBody("field1", "value1")
+    // .addBinaryBody("fileItem", tempFile.toFile(), ContentType.create("application/octet-stream"), "file1.txt").build();
+    //
+    // final HttpPost post = new HttpPost("http://localhost:9000/params-file");
+    // post.setEntity(entity);
+    //
+    // try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create().build().execute(post);) {
+    // assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo("file1.txt");
+    // }
+    // }
+
+    @Test
+    public void givenHeader_whenSet_thenRetrieveWithGet() throws Exception {
+        final HttpUriRequest request = new HttpGet("http://localhost:9000/params/header");
+        request.addHeader("customheader", "foobar");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo("foobar");
+        }
+    }
+
+    @Test
+    public void givenNoCookie_whenCalled_thenReadDefaultValue() throws Exception {
+        
+        final HttpUriRequest request = new HttpGet("http://localhost:9000/params/cookie");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo("default value");
+        }
+
+    }
+
+}

blade/src/test/java/com/baeldung/blade/sample/RouteExampleControllerLiveTest.java

@@ -0,0 +1,117 @@
+package com.baeldung.blade.sample;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpDelete;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.client.methods.HttpPut;
+import org.apache.http.client.methods.HttpUriRequest;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.util.EntityUtils;
+import org.junit.Test;
+
+public class RouteExampleControllerLiveTest {
+
+    @Test
+    public void givenRoute_whenGet_thenCorrectOutput() throws Exception {
+        final HttpUriRequest request = new HttpGet("http://localhost:9000/route-example");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo("GET called");
+        }
+    }
+
+    @Test
+    public void givenRoute_whenPost_thenCorrectOutput() throws Exception {
+        final HttpUriRequest request = new HttpPost("http://localhost:9000/route-example");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo("POST called");
+        }
+    }
+
+    @Test
+    public void givenRoute_whenPut_thenCorrectOutput() throws Exception {
+        final HttpUriRequest request = new HttpPut("http://localhost:9000/route-example");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo("PUT called");
+        }
+    }
+
+    @Test
+    public void givenRoute_whenDelete_thenCorrectOutput() throws Exception {
+        final HttpUriRequest request = new HttpDelete("http://localhost:9000/route-example");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo("DELETE called");
+        }
+    }
+
+    @Test
+    public void givenAnotherRoute_whenGet_thenCorrectOutput() throws Exception {
+        final HttpUriRequest request = new HttpGet("http://localhost:9000/another-route-example");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo("GET called");
+        }
+    }
+
+    @Test
+    public void givenAllMatchRoute_whenGet_thenCorrectOutput() throws Exception {
+        final HttpUriRequest request = new HttpGet("http://localhost:9000/allmatch-route-example");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo("ALLMATCH called");
+        }
+    }
+
+    @Test
+    public void givenAllMatchRoute_whenPost_thenCorrectOutput() throws Exception {
+        final HttpUriRequest request = new HttpPost("http://localhost:9000/allmatch-route-example");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo("ALLMATCH called");
+        }
+    }
+
+    @Test
+    public void givenAllMatchRoute_whenPut_thenCorrectOutput() throws Exception {
+        final HttpUriRequest request = new HttpPut("http://localhost:9000/allmatch-route-example");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo("ALLMATCH called");
+        }
+    }
+
+    @Test
+    public void givenAllMatchRoute_whenDelete_thenCorrectOutput() throws Exception {
+        final HttpUriRequest request = new HttpDelete("http://localhost:9000/allmatch-route-example");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo("ALLMATCH called");
+        }
+    }
+
+    @Test
+    public void givenRequestAttribute_whenRenderedWithTemplate_thenCorrectlyEvaluateIt() throws Exception {
+        final HttpUriRequest request = new HttpGet("http://localhost:9000/template-output-test");
+        try (final CloseableHttpResponse httpResponse = HttpClientBuilder.create()
+            .build()
+            .execute(request);) {
+            assertThat(EntityUtils.toString(httpResponse.getEntity())).isEqualTo("<h1>Hello, Blade!</h1>");
+        }
+    }
+    
+}

core-java-8/src/test/java/com/baeldung/java8/lambda/methodreference/Bicycle.java

@@ -0,0 +1,29 @@
+package com.baeldung.java8.lambda.methodreference;
+
+public class Bicycle {
+
+    private String brand;
+    private Integer frameSize;
+
+    public Bicycle(String brand, Integer frameSize) {
+        this.brand = brand;
+        this.frameSize = frameSize;
+    }
+
+    public String getBrand() {
+        return brand;
+    }
+
+    public void setBrand(String brand) {
+        this.brand = brand;
+    }
+
+    public Integer getFrameSize() {
+        return frameSize;
+    }
+
+    public void setFrameSize(Integer frameSize) {
+        this.frameSize = frameSize;
+    }
+
+}

core-java-8/src/test/java/com/baeldung/java8/lambda/methodreference/BicycleComparator.java

@@ -0,0 +1,13 @@
+package com.baeldung.java8.lambda.methodreference;
+
+import java.util.Comparator;
+
+public class BicycleComparator implements Comparator<Bicycle> {
+
+    @Override
+    public int compare(Bicycle a, Bicycle b) {
+        return a.getFrameSize()
+            .compareTo(b.getFrameSize());
+    }
+
+}

core-java-8/src/test/java/com/baeldung/java8/lambda/methodreference/MethodReferenceExamples.java

@@ -0,0 +1,70 @@
+package com.baeldung.java8.lambda.methodreference;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.BiFunction;
+
+import org.junit.Test;
+
+public class MethodReferenceExamples {
+
+    private static <T> void doNothingAtAll(Object... o) {
+    }
+
+    ;
+
+    @Test
+    public void referenceToStaticMethod() {
+        List<String> messages = Arrays.asList("Hello", "Baeldung", "readers!");
+        messages.forEach((word) -> {
+            System.out.println(word);
+        });
+        messages.forEach(System.out::println);
+    }
+
+    @Test
+    public void referenceToInstanceMethodOfParticularObject() {
+        BicycleComparator bikeFrameSizeComparator = new BicycleComparator();
+        createBicyclesList().stream()
+            .sorted((a, b) -> bikeFrameSizeComparator.compare(a, b));
+        createBicyclesList().stream()
+            .sorted(bikeFrameSizeComparator::compare);
+    }
+
+    @Test
+    public void referenceToInstanceMethodOfArbitratyObjectOfParticularType() {
+        List<Integer> numbers = Arrays.asList(5, 3, 50, 24, 40, 2, 9, 18);
+        numbers.stream()
+            .sorted((a, b) -> Integer.compare(a, b));
+        numbers.stream()
+            .sorted(Integer::compare);
+    }
+
+    @Test
+    public void referenceToConstructor() {
+        BiFunction<String, Integer, Bicycle> bikeCreator = (brand, frameSize) -> new Bicycle(brand, frameSize);
+        BiFunction<String, Integer, Bicycle> bikeCreatorMethodReference = Bicycle::new;
+        List<Bicycle> bikes = new ArrayList<>();
+        bikes.add(bikeCreator.apply("Giant", 50));
+        bikes.add(bikeCreator.apply("Scott", 20));
+        bikes.add(bikeCreatorMethodReference.apply("Trek", 35));
+        bikes.add(bikeCreatorMethodReference.apply("GT", 40));
+    }
+
+    @Test
+    public void limitationsAndAdditionalExamples() {
+        createBicyclesList().forEach(b -> System.out.printf("Bike brand is '%s' and frame size is '%d'%n", b.getBrand(), b.getFrameSize()));
+        createBicyclesList().forEach((o) -> this.doNothingAtAll(o));
+    }
+
+    private List<Bicycle> createBicyclesList() {
+        List<Bicycle> bikes = new ArrayList<>();
+        bikes.add(new Bicycle("Giant", 50));
+        bikes.add(new Bicycle("Scott", 20));
+        bikes.add(new Bicycle("Trek", 35));
+        bikes.add(new Bicycle("GT", 40));
+        return bikes;
+    }
+
+}

core-java-8/src/test/java/com/baeldung/time/InstantUnitTest.java

@@ -0,0 +1,42 @@
+package com.baeldung.time;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import java.time.Clock;
+import java.time.Instant;
+import java.time.ZoneId;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.when;
+import static org.powermock.api.mockito.PowerMockito.mockStatic;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({ Instant.class })
+public class InstantUnitTest {
+
+    @Test
+    public void givenInstantMock_whenNow_thenGetFixedInstant() {
+        String instantExpected = "2014-12-22T10:15:30Z";
+        Clock clock = Clock.fixed(Instant.parse(instantExpected), ZoneId.of("UTC"));
+        Instant instant = Instant.now(clock);
+        mockStatic(Instant.class);
+        when(Instant.now()).thenReturn(instant);
+
+        Instant now = Instant.now();
+
+        assertThat(now.toString()).isEqualTo(instantExpected);
+    }
+
+    @Test
+    public void givenFixedClock_whenNow_thenGetFixedInstant() {
+        String instantExpected = "2014-12-22T10:15:30Z";
+        Clock clock = Clock.fixed(Instant.parse(instantExpected), ZoneId.of("UTC"));
+
+        Instant instant = Instant.now(clock);
+
+        assertThat(instant.toString()).isEqualTo(instantExpected);
+    }
+}

core-java-8/src/test/java/com/baeldung/time/InstantWithJMockUnitTest.java

@@ -0,0 +1,47 @@
+package com.baeldung.time;
+
+import mockit.Expectations;
+import mockit.Mock;
+import mockit.MockUp;
+import org.junit.jupiter.api.Test;
+
+import java.time.Clock;
+import java.time.Instant;
+import java.time.ZoneId;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class InstantWithJMockUnitTest {
+
+    @Test
+    public void givenInstantWithJMock_whenNow_thenGetFixedInstant() {
+        String instantExpected = "2014-12-21T10:15:30Z";
+        Clock clock = Clock.fixed(Instant.parse(instantExpected), ZoneId.of("UTC"));
+        new MockUp<Instant>() {
+            @Mock
+            public Instant now() {
+                return Instant.now(clock);
+            }
+        };
+
+        Instant now = Instant.now();
+
+        assertThat(now.toString()).isEqualTo(instantExpected);
+    }
+
+    @Test
+    public void givenInstantWithExpectations_whenNow_thenGetFixedInstant() {
+        Clock clock = Clock.fixed(Instant.parse("2014-12-23T10:15:30.00Z"), ZoneId.of("UTC"));
+        Instant instantExpected = Instant.now(clock);
+        new Expectations(Instant.class) {
+            {
+                Instant.now();
+                result = instantExpected;
+            }
+        };
+
+        Instant now = Instant.now();
+
+        assertThat(now).isEqualTo(instantExpected);
+    }
+}

core-java-arrays/src/main/java/com/baeldung/array/conversions/FloatToByteArray.java

@@ -0,0 +1,44 @@
+package com.baeldung.array.conversions;
+
+import java.nio.ByteBuffer;
+
+public class FloatToByteArray {
+    
+    /**
+     * convert float into byte array using Float API floatToIntBits 
+     * @param value
+     * @return byte[]
+     */
+    public static byte[] floatToByteArray(float value) {
+        int intBits =  Float.floatToIntBits(value);
+        return new byte[] {(byte) (intBits >> 24), (byte) (intBits >> 16), (byte) (intBits >> 8), (byte) (intBits) };
+    }
+    
+    /**
+     * convert byte array into float using Float API intBitsToFloat
+     * @param bytes
+     * @return float
+     */
+    public static float byteArrayToFloat(byte[] bytes) {
+        int intBits =  bytes[0] << 24 | (bytes[1] & 0xFF) << 16 | (bytes[2] & 0xFF) << 8 | (bytes[3] & 0xFF);
+        return Float.intBitsToFloat(intBits);
+    }
+    
+    /**
+     * convert float into byte array using ByteBuffer
+     * @param value
+     * @return byte[]
+     */
+    public static byte[] floatToByteArrayWithByteBuffer(float value) {
+        return ByteBuffer.allocate(4).putFloat(value).array();
+    }
+    
+    /**
+     * convert byte array into float using ByteBuffer
+     * @param bytes
+     * @return float
+     */
+    public static float byteArrayToFloatWithByteBuffer(byte[] bytes) {
+        return ByteBuffer.wrap(bytes).getFloat();
+    }
+}

core-java-arrays/src/main/java/com/baeldung/arrays/ParallelPrefixBenchmark.java

@@ -0,0 +1,44 @@
+package com.baeldung.arrays;
+
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.infra.Blackhole;
+
+import java.util.Arrays;
+
+public class ParallelPrefixBenchmark {
+  private static final int ARRAY_SIZE = 200_000_000;
+
+  @State(Scope.Benchmark)
+  public static class BigArray {
+
+    int[] data;
+
+    @Setup(Level.Iteration)
+    public void prepare() {
+      data = new int[ARRAY_SIZE];
+      for(int j = 0; j< ARRAY_SIZE; j++) {
+        data[j] = 1;
+      }
+    }
+
+    @TearDown(Level.Iteration)
+    public void destroy() {
+      data = null;
+    }
+
+  }
+
+  @Benchmark
+  public void largeArrayLoopSum(BigArray bigArray, Blackhole blackhole) {
+    for (int i = 0; i < ARRAY_SIZE - 1; i++) {
+      bigArray.data[i + 1] += bigArray.data[i];
+    }
+    blackhole.consume(bigArray.data);
+  }
+
+  @Benchmark
+  public void largeArrayParallelPrefixSum(BigArray bigArray, Blackhole blackhole) {
+    Arrays.parallelPrefix(bigArray.data, (left, right) -> left + right);
+    blackhole.consume(bigArray.data);
+  }
+}

core-java-arrays/src/test/java/com/baeldung/array/conversions/FloatToByteArrayUnitTest.java

@@ -0,0 +1,46 @@
+package com.baeldung.array.conversions;
+
+import static com.baeldung.array.conversions.FloatToByteArray.byteArrayToFloat;
+import static com.baeldung.array.conversions.FloatToByteArray.byteArrayToFloatWithByteBuffer;
+import static com.baeldung.array.conversions.FloatToByteArray.floatToByteArray;
+import static com.baeldung.array.conversions.FloatToByteArray.floatToByteArrayWithByteBuffer;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import org.junit.Test;
+
+public class FloatToByteArrayUnitTest {
+
+    @Test
+    public void givenAFloat_thenConvertToByteArray() {
+        assertArrayEquals(new byte[] { 63, -116, -52, -51}, floatToByteArray(1.1f));
+    }
+
+    @Test
+    public void givenAByteArray_thenConvertToFloat() {
+        assertEquals(1.1f, byteArrayToFloat(new byte[] { 63, -116, -52, -51}), 0);
+    }
+
+    @Test
+    public void givenAFloat_thenConvertToByteArrayUsingByteBuffer() {
+        assertArrayEquals(new byte[] { 63, -116, -52, -51}, floatToByteArrayWithByteBuffer(1.1f));
+    }
+
+    @Test
+    public void givenAByteArray_thenConvertToFloatUsingByteBuffer() {
+        assertEquals(1.1f, byteArrayToFloatWithByteBuffer(new byte[] { 63, -116, -52, -51}), 0);
+    }
+
+    @Test
+    public void givenAFloat_thenConvertToByteArray_thenConvertToFloat() {
+        float floatToConvert = 200.12f;
+        byte[] byteArray = floatToByteArray(floatToConvert);
+        assertEquals(200.12f, byteArrayToFloat(byteArray), 0);
+    }
+    
+    @Test
+    public void givenAFloat_thenConvertToByteArrayWithByteBuffer_thenConvertToFloatWithByteBuffer() {
+        float floatToConvert = 30100.42f;
+        byte[] byteArray = floatToByteArrayWithByteBuffer(floatToConvert);
+        assertEquals(30100.42f, byteArrayToFloatWithByteBuffer(byteArray), 0);
+    }
+}

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

@@ -1,5 +1,7 @@
 package com.baeldung.arrays;
 
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
 import static org.junit.Assert.*;
 
 import org.junit.Before;
@@ -9,6 +11,7 @@ import org.junit.rules.ExpectedException;
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.Random;
 import java.util.stream.Stream;
 
 public class ArraysUnitTest {
@@ -150,4 +153,52 @@ public class ArraysUnitTest {
         exception.expect(UnsupportedOperationException.class);
         rets.add("the");
     }
+
+    @Test
+    public void givenIntArray_whenPrefixAdd_thenAllAccumulated() {
+        int[] arri = new int[] { 1, 2, 3, 4};
+        Arrays.parallelPrefix(arri, (left, right) -> left + right);
+        assertThat(arri, is(new int[] { 1, 3, 6, 10}));
+    }
+
+    @Test
+    public void givenStringArray_whenPrefixConcat_thenAllMerged() {
+        String[] arrs = new String[] { "1", "2", "3" };
+        Arrays.parallelPrefix(arrs, (left, right) -> left + right);
+        assertThat(arrs, is(new String[] { "1", "12", "123" }));
+    }
+
+    @Test
+    public void whenPrefixAddWithRange_thenRangeAdded() {
+        int[] arri = new int[] { 1, 2, 3, 4, 5 };
+        Arrays.parallelPrefix(arri, 1, 4, (left, right) -> left + right);
+        assertThat(arri, is(new int[] { 1, 2, 5, 9, 5 }));
+    }
+
+    @Test
+    public void whenPrefixNonAssociative_thenError() {
+        boolean consistent = true;
+        Random r = new Random();
+        for (int k = 0; k < 100_000; k++) {
+            int[] arrA = r.ints(100, 1, 5).toArray();
+            int[] arrB = Arrays.copyOf(arrA, arrA.length);
+
+            Arrays.parallelPrefix(arrA, this::nonassociativeFunc);
+
+            for (int i = 1; i < arrB.length; i++) {
+                arrB[i] = nonassociativeFunc(arrB[i - 1], arrB[i]);
+            }
+            consistent = Arrays.equals(arrA, arrB);
+            if(!consistent) break;
+        }
+        assertFalse(consistent);
+    }
+
+    /**
+     * non-associative int binary operator
+     */
+    private int nonassociativeFunc(int left, int right) {
+        return left + right*left;
+    }
+
 }

core-java-collections-list/README.md

@@ -26,3 +26,4 @@
 - [ClassCastException: Arrays$ArrayList cannot be cast to ArrayList](https://www.baeldung.com/java-classcastexception-arrays-arraylist)
 - [Flattening Nested Collections in Java](http://www.baeldung.com/java-flatten-nested-collections)
 - [Intersection of Two Lists in Java](https://www.baeldung.com/java-lists-intersection)
+- [Multi Dimensional ArrayList in Java](https://www.baeldung.com/java-multi-dimensional-arraylist)

core-java-concurrency-basic/README.md

@@ -14,4 +14,5 @@
 - [ExecutorService - Waiting for Threads to Finish](http://www.baeldung.com/java-executor-wait-for-threads)
 - [wait and notify() Methods in Java](http://www.baeldung.com/java-wait-notify)
 - [Life Cycle of a Thread in Java](http://www.baeldung.com/java-thread-lifecycle)
-- [Runnable vs. Callable in Java](http://www.baeldung.com/java-runnable-callable)
+- [Runnable vs. Callable in Java](http://www.baeldung.com/java-runnable-callable)
+- [What is Thread-Safety and How to Achieve it](https://www.baeldung.com/java-thread-safety)

core-java-io/src/main/java/com/baeldung/csv/WriteCsvFileExample.java

@@ -1,18 +1,14 @@
 package com.baeldung.csv;
 
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
 public class WriteCsvFileExample {
 
     public String convertToCSV(String[] data) {
-        StringBuilder csvLine = new StringBuilder();
-
-        for (int i = 0; i < data.length; i++) {
-            if (i > 0) {
-                csvLine.append(",");
-            }
-            csvLine.append(escapeSpecialCharacters(data[i]));
-        }
-
-        return csvLine.toString();
+        return Stream.of(data)
+            .map(this::escapeSpecialCharacters)
+            .collect(Collectors.joining(","));
     }
 
     public String escapeSpecialCharacters(String data) {

core-java-io/src/main/java/com/baeldung/files/ListFiles.java

@@ -0,0 +1,64 @@
+package com.baeldung.files;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.DirectoryStream;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class ListFiles {
+    public static final int DEPTH = 1;
+
+    public Set<String> listFilesUsingJavaIO(String dir) {
+        return Stream.of(new File(dir).listFiles())
+            .filter(file -> !file.isDirectory())
+            .map(File::getName)
+            .collect(Collectors.toSet());
+    }
+
+    public Set<String> listFilesUsingFileWalk(String dir, int depth) throws IOException {
+        try (Stream<Path> stream = Files.walk(Paths.get(dir), depth)) {
+            return stream.filter(file -> !Files.isDirectory(file))
+                .map(Path::getFileName)
+                .map(Path::toString)
+                .collect(Collectors.toSet());
+        }
+    }
+
+    public Set<String> listFilesUsingFileWalkAndVisitor(String dir) throws IOException {
+        Set<String> fileList = new HashSet<>();
+        Files.walkFileTree(Paths.get(dir), new SimpleFileVisitor<Path>() {
+            @Override
+            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
+                if (!Files.isDirectory(file)) {
+                    fileList.add(file.getFileName()
+                        .toString());
+                }
+                return FileVisitResult.CONTINUE;
+            }
+        });
+        return fileList;
+    }
+
+    public Set<String> listFilesUsingDirectoryStream(String dir) throws IOException {
+        Set<String> fileList = new HashSet<>();
+        try (DirectoryStream<Path> stream = Files.newDirectoryStream(Paths.get(dir))) {
+            for (Path path : stream) {
+                if (!Files.isDirectory(path)) {
+                    fileList.add(path.getFileName()
+                        .toString());
+                }
+            }
+        }
+        return fileList;
+    }
+
+}

core-java-io/src/test/java/com/baeldung/csv/WriteCsvFileExampleUnitTest.java

@@ -65,7 +65,7 @@ public class WriteCsvFileExampleUnitTest {
     }
 
     @Test
-    public void givenBufferedWriter_whenWriteLine_thenOutputCreated() {
+    public void givenDataArray_whenConvertToCSV_thenOutputCreated() {
         List<String[]> dataLines = new ArrayList<String[]>();
         dataLines.add(new String[] { "John", "Doe", "38", "Comment Data\nAnother line of comment data" });
         dataLines.add(new String[] { "Jane", "Doe, Jr.", "19", "She said \"I'm being quoted\"" });

core-java-io/src/test/java/com/baeldung/directories/NewDirectoryUnitTest.java

@@ -0,0 +1,100 @@
+package com.baeldung.directories;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class NewDirectoryUnitTest {
+
+    private static final File TEMP_DIRECTORY = new File(System.getProperty("java.io.tmpdir"));
+
+    @Before
+    public void beforeEach() {
+        File newDirectory = new File(TEMP_DIRECTORY, "new_directory");
+        File nestedInNewDirectory = new File(newDirectory, "nested_directory");
+        File existingDirectory = new File(TEMP_DIRECTORY, "existing_directory");
+        File existingNestedDirectory = new File(existingDirectory, "existing_nested_directory");
+        File nestedInExistingDirectory = new File(existingDirectory, "nested_directory");
+
+        nestedInNewDirectory.delete();
+        newDirectory.delete();
+        nestedInExistingDirectory.delete();
+        existingDirectory.mkdir();
+        existingNestedDirectory.mkdir();
+    }
+
+    @Test
+    public void givenUnexistingDirectory_whenMkdir_thenTrue() {
+        File newDirectory = new File(TEMP_DIRECTORY, "new_directory");
+        assertFalse(newDirectory.exists());
+
+        boolean directoryCreated = newDirectory.mkdir();
+
+        assertTrue(directoryCreated);
+    }
+
+    @Test
+    public void givenExistingDirectory_whenMkdir_thenFalse() {
+        File newDirectory = new File(TEMP_DIRECTORY, "new_directory");
+        newDirectory.mkdir();
+        assertTrue(newDirectory.exists());
+
+        boolean directoryCreated = newDirectory.mkdir();
+
+        assertFalse(directoryCreated);
+    }
+
+    @Test
+    public void givenUnexistingNestedDirectories_whenMkdir_thenFalse() {
+        File newDirectory = new File(TEMP_DIRECTORY, "new_directory");
+        File nestedDirectory = new File(newDirectory, "nested_directory");
+        assertFalse(newDirectory.exists());
+        assertFalse(nestedDirectory.exists());
+
+        boolean directoriesCreated = nestedDirectory.mkdir();
+
+        assertFalse(directoriesCreated);
+    }
+
+    @Test
+    public void givenUnexistingNestedDirectories_whenMkdirs_thenTrue() {
+        File newDirectory = new File(System.getProperty("java.io.tmpdir") + File.separator + "new_directory");
+        File nestedDirectory = new File(newDirectory, "nested_directory");
+        assertFalse(newDirectory.exists());
+        assertFalse(nestedDirectory.exists());
+
+        boolean directoriesCreated = nestedDirectory.mkdirs();
+
+        assertTrue(directoriesCreated);
+    }
+
+    @Test
+    public void givenExistingParentDirectories_whenMkdirs_thenTrue() {
+        File newDirectory = new File(TEMP_DIRECTORY, "existing_directory");
+        newDirectory.mkdir();
+        File nestedDirectory = new File(newDirectory, "nested_directory");
+        assertTrue(newDirectory.exists());
+        assertFalse(nestedDirectory.exists());
+
+        boolean directoriesCreated = nestedDirectory.mkdirs();
+
+        assertTrue(directoriesCreated);
+    }
+
+    @Test
+    public void givenExistingNestedDirectories_whenMkdirs_thenFalse() {
+        File existingDirectory = new File(TEMP_DIRECTORY, "existing_directory");
+        File existingNestedDirectory = new File(existingDirectory, "existing_nested_directory");
+        assertTrue(existingDirectory.exists());
+        assertTrue(existingNestedDirectory.exists());
+
+        boolean directoriesCreated = existingNestedDirectory.mkdirs();
+
+        assertFalse(directoriesCreated);
+    }
+
+}

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

@@ -0,0 +1,96 @@
+package com.baeldung.file;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.nio.channels.FileChannel;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+
+import org.apache.commons.io.FileUtils;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.baeldung.util.StreamUtils;
+
+public class FilesClearDataUnitTest {
+	
+    public static final String FILE_PATH = "src/test/resources/fileexample.txt";
+
+    @Before
+    @After
+    public void setup() throws IOException {
+        PrintWriter writer = new PrintWriter(FILE_PATH);
+        writer.print("This example shows how we can delete the file contents without deleting the file");
+        writer.close();
+    }
+    
+    @Test
+    public void givenExistingFile_whenDeleteContentUsingPrintWritter_thenEmptyFile() throws IOException {
+        PrintWriter writer = new PrintWriter(FILE_PATH);
+        writer.print("");
+        writer.close();
+        assertEquals(0, StreamUtils.getStringFromInputStream(new FileInputStream(FILE_PATH)).length());
+    }    
+
+    @Test
+    public void givenExistingFile_whenDeleteContentUsingPrintWritterWithougObject_thenEmptyFile() throws IOException {
+        new PrintWriter(FILE_PATH).close();
+        assertEquals(0, StreamUtils.getStringFromInputStream(new FileInputStream(FILE_PATH)).length());
+    }    
+       
+    @Test
+    public void givenExistingFile_whenDeleteContentUsingFileWriter_thenEmptyFile() throws IOException {
+        new FileWriter(FILE_PATH, false).close();
+ 
+        assertEquals(0, StreamUtils.getStringFromInputStream(new FileInputStream(FILE_PATH)).length());
+    }
+    
+    @Test
+    public void givenExistingFile_whenDeleteContentUsingFileOutputStream_thenEmptyFile() throws IOException {
+        new FileOutputStream(FILE_PATH).close();
+
+        assertEquals(0, StreamUtils.getStringFromInputStream(new FileInputStream(FILE_PATH)).length());
+    }    
+
+    @Test
+    public void givenExistingFile_whenDeleteContentUsingFileUtils_thenEmptyFile() throws IOException {
+        FileUtils.write(new File(FILE_PATH), "", Charset.defaultCharset());
+
+        assertEquals(0, StreamUtils.getStringFromInputStream(new FileInputStream(FILE_PATH)).length());
+    }    
+
+    @Test
+    public void givenExistingFile_whenDeleteContentUsingNIOFiles_thenEmptyFile() throws IOException {
+        BufferedWriter writer = Files.newBufferedWriter(Paths.get(FILE_PATH));
+        writer.write("");
+        writer.flush();
+ 
+        assertEquals(0, StreamUtils.getStringFromInputStream(new FileInputStream(FILE_PATH)).length());
+    }    
+    
+    @Test
+    public void givenExistingFile_whenDeleteContentUsingNIOFileChannel_thenEmptyFile() throws IOException {
+        FileChannel.open(Paths.get(FILE_PATH), StandardOpenOption.WRITE).truncate(0).close();
+ 
+        assertEquals(0, StreamUtils.getStringFromInputStream(new FileInputStream(FILE_PATH)).length());
+    }   
+    
+    @Test
+    public void givenExistingFile_whenDeleteContentUsingGuava_thenEmptyFile() throws IOException {
+        File file = new File(FILE_PATH);
+        byte[] empty = new byte[0];
+        com.google.common.io.Files.write(empty, file);
+        
+        assertEquals(0, StreamUtils.getStringFromInputStream(new FileInputStream(FILE_PATH)).length());
+    }    
+}

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

@@ -0,0 +1,46 @@
+package com.baeldung.file;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.junit.Test;
+
+import com.baeldung.files.ListFiles;
+
+public class ListFilesUnitTest {
+
+    private ListFiles listFiles = new ListFiles();
+    private String DIRECTORY = "src/test/resources/listFilesUnitTestFolder";
+    private static final int DEPTH = 1;
+    private Set<String> EXPECTED_FILE_LIST = new HashSet<String>() {
+        {
+            add("test.xml");
+            add("employee.json");
+            add("students.json");
+            add("country.txt");
+        }
+    };
+
+    @Test
+    public void givenDir_whenUsingJAVAIO_thenListAllFiles() throws IOException {
+        assertEquals(EXPECTED_FILE_LIST, listFiles.listFilesUsingJavaIO(DIRECTORY));
+    }
+
+    @Test
+    public void givenDir_whenWalkingTree_thenListAllFiles() throws IOException {
+        assertEquals(EXPECTED_FILE_LIST, listFiles.listFilesUsingFileWalk(DIRECTORY,DEPTH));
+    }
+
+    @Test
+    public void givenDir_whenWalkingTreeWithVisitor_thenListAllFiles() throws IOException {
+        assertEquals(EXPECTED_FILE_LIST, listFiles.listFilesUsingFileWalkAndVisitor(DIRECTORY));
+    }
+
+    @Test
+    public void givenDir_whenUsingDirectoryStream_thenListAllFiles() throws IOException {
+        assertEquals(EXPECTED_FILE_LIST, listFiles.listFilesUsingDirectoryStream(DIRECTORY));
+    }
+}

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

@@ -1,60 +1,56 @@
 package org.baeldung.java.io;
 
-
+import com.google.common.io.ByteSource;
 import com.google.common.io.ByteStreams;
 import org.apache.commons.io.IOUtils;
-import org.junit.jupiter.api.Test;
+import org.junit.Test;
 
-import java.io.File;
-import java.io.FileInputStream;
+import java.io.ByteArrayInputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.nio.ByteBuffer;
 import java.nio.channels.ReadableByteChannel;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static java.nio.channels.Channels.newChannel;
+import static org.junit.Assert.assertEquals;
 
-class InputStreamToByteBufferUnitTest {
+public class InputStreamToByteBufferUnitTest {
 
     @Test
-    public void givenUsingCoreClasses_whenWritingAFileIntoAByteBuffer_thenBytesLengthMustMatch() throws IOException {
-        File inputFile = getFile();
-        ByteBuffer bufferByte = ByteBuffer.allocate((int) inputFile.length());
-        FileInputStream in = new FileInputStream(inputFile);
-        in.getChannel().read(bufferByte);
+    public void givenUsingCoreClasses_whenByteArrayInputStreamToAByteBuffer_thenLengthMustMatch() throws IOException {
+        byte[] input = new byte[] { 0, 1, 2 };
+        InputStream initialStream = new ByteArrayInputStream(input);
+        ByteBuffer byteBuffer = ByteBuffer.allocate(3);
+        while (initialStream.available() > 0) {
+            byteBuffer.put((byte) initialStream.read());
+        }
 
-        assertEquals(bufferByte.position(), inputFile.length());
+        assertEquals(byteBuffer.position(), input.length);
     }
 
     @Test
-    public void givenUsingCommonsIo_whenWritingAFileIntoAByteBuffer_thenBytesLengthMustMatch() throws IOException {
-        File inputFile = getFile();
-        ByteBuffer bufferByte = ByteBuffer.allocateDirect((int) inputFile.length());
-        ReadableByteChannel readableByteChannel = new FileInputStream(inputFile).getChannel();
-        IOUtils.readFully(readableByteChannel, bufferByte);
-
-        assertEquals(bufferByte.position(), inputFile.length());
-    }
-
-    @Test
-    public void givenUsingGuava_whenWritingAFileIntoAByteBuffer_thenBytesLengthMustMatch() throws IOException {
-        File inputFile = getFile();
-        FileInputStream in = new FileInputStream(inputFile);
-        byte[] targetArray = ByteStreams.toByteArray(in);
+    public void givenUsingGuava__whenByteArrayInputStreamToAByteBuffer_thenLengthMustMatch() throws IOException {
+        InputStream initialStream = ByteSource
+          .wrap(new byte[] { 0, 1, 2 })
+          .openStream();
+        byte[] targetArray = ByteStreams.toByteArray(initialStream);
         ByteBuffer bufferByte = ByteBuffer.wrap(targetArray);
-        bufferByte.rewind();
         while (bufferByte.hasRemaining()) {
             bufferByte.get();
         }
-        
-        assertEquals(bufferByte.position(), inputFile.length());
+
+        assertEquals(bufferByte.position(), targetArray.length);
     }
 
-    private File getFile() {
-        ClassLoader classLoader = new InputStreamToByteBufferUnitTest().getClass().getClassLoader();
+    @Test
+    public void givenUsingCommonsIo_whenByteArrayInputStreamToAByteBuffer_thenLengthMustMatch() throws IOException {
+        byte[] input = new byte[] { 0, 1, 2 };
+        InputStream initialStream = new ByteArrayInputStream(input);
+        ByteBuffer byteBuffer = ByteBuffer.allocate(3);
+        ReadableByteChannel channel = newChannel(initialStream);
+        IOUtils.readFully(channel, byteBuffer);
 
-        String fileName = "frontenac-2257154_960_720.jpg";
-
-        return new File(classLoader.getResource(fileName).getFile());
+        assertEquals(byteBuffer.position(), input.length);
     }
 
 }

core-java-io/src/test/resources/fileexample.txt

@@ -0,0 +1 @@
+This example shows how we can delete the file contents without deleting the file

core-java-io/src/test/resources/listFilesUnitTestFolder/country.txt

@@ -0,0 +1 @@
+This is a sample txt file for unit test ListFilesUnitTest

core-java-io/src/test/resources/listFilesUnitTestFolder/employee.json

@@ -0,0 +1 @@
+{}

core-java-io/src/test/resources/listFilesUnitTestFolder/students.json

@@ -0,0 +1 @@
+{}

core-java-io/src/test/resources/listFilesUnitTestFolder/test.xml

@@ -0,0 +1 @@
+<xml></xml>

core-java-lang-syntax/src/main/java/com/baeldung/keyword/Circle.java

@@ -0,0 +1,5 @@
+package com.baeldung.keyword;
+
+public class Circle extends Round implements Shape {
+
+}

core-java-lang-syntax/src/main/java/com/baeldung/keyword/Ring.java

@@ -0,0 +1,4 @@
+package com.baeldung.keyword;
+
+public class Ring extends Round {
+}

core-java-lang-syntax/src/main/java/com/baeldung/keyword/Round.java

@@ -0,0 +1,4 @@
+package com.baeldung.keyword;
+
+public class Round {
+}

core-java-lang-syntax/src/main/java/com/baeldung/keyword/Shape.java

@@ -0,0 +1,4 @@
+package com.baeldung.keyword;
+
+public interface Shape {
+}

core-java-lang-syntax/src/main/java/com/baeldung/keyword/Triangle.java

@@ -0,0 +1,4 @@
+package com.baeldung.keyword;
+
+public class Triangle implements Shape {
+}

core-java-lang-syntax/src/test/java/com/baeldung/keyword/test/InstanceOfUnitTest.java

@@ -0,0 +1,55 @@
+package com.baeldung.keyword.test;
+
+import org.junit.Assert;
+import org.junit.jupiter.api.Test;
+
+import com.baeldung.keyword.Circle;
+import com.baeldung.keyword.Ring;
+import com.baeldung.keyword.Round;
+import com.baeldung.keyword.Shape;
+import com.baeldung.keyword.Triangle;
+
+public class InstanceOfUnitTest {
+
+    @Test
+    public void giveWhenInstanceIsCorrect_thenReturnTrue() {
+        Ring ring = new Ring();
+        Assert.assertTrue("ring is instance of Round ", ring instanceof Round);
+    }
+
+    @Test
+    public void giveWhenObjectIsInstanceOfType_thenReturnTrue() {
+        Circle circle = new Circle();
+        Assert.assertTrue("circle is instance of Circle ", circle instanceof Circle);
+    }
+
+  
+    @Test
+    public void giveWhenInstanceIsOfSubtype_thenReturnTrue() {
+        Circle circle = new Circle();
+        Assert.assertTrue("circle is instance of Round", circle instanceof Round);
+    }
+
+    @Test
+    public void giveWhenTypeIsInterface_thenReturnTrue() {
+        Circle circle = new Circle();
+        Assert.assertTrue("circle is instance of Shape", circle instanceof Shape);
+    }
+    
+    @Test
+    public void giveWhenTypeIsOfObjectType_thenReturnTrue() {
+        Thread thread = new Thread();
+        Assert.assertTrue("thread is instance of Object", thread instanceof Object);
+    }
+
+    @Test
+    public void giveWhenInstanceValueIsNull_thenReturnFalse() {
+        Circle circle = null;
+        Assert.assertFalse("circle is instance of Round", circle instanceof Round);
+    }
+
+    @Test
+    public void giveWhenComparingClassInDiffHierarchy_thenCompilationError() {
+        // Assert.assertFalse("circle is instance of Triangle", circle instanceof Triangle);
+    }
+}

core-java-lang/src/main/java/com/baeldung/objects/Car.java

@@ -0,0 +1,51 @@
+package com.baeldung.objects;
+
+public class Car {
+
+    private String type;
+    private String model;
+    private String color;
+    private int speed;
+
+    public Car(String type, String model, String color) {
+        this.type = type;
+        this.model = model;
+        this.color = color;
+    }
+
+    public String getColor() {
+        return color;
+    }
+
+    public void setColor(String color) {
+        this.color = color;
+    }
+
+    public int getSpeed() {
+        return speed;
+    }
+    
+    public int increaseSpeed(int increment) {
+        if (increment > 0) {
+            this.speed += increment;
+        } else {
+            System.out.println("Increment can't be negative.");
+        }
+        return this.speed;
+    }
+    
+    public int decreaseSpeed(int decrement) {
+        if (decrement > 0 && decrement <= this.speed) {
+            this.speed -= decrement;
+        } else {
+            System.out.println("Decrement can't be negative or greater than current speed.");
+        }
+        return this.speed;
+    }
+
+    @Override
+    public String toString() {
+        return "Car [type=" + type + ", model=" + model + ", color=" + color + ", speed=" + speed + "]";
+    }
+    
+}

core-java-lang/src/main/java/com/baeldung/scope/BracketScopeExample.java

@@ -0,0 +1,14 @@
+package org.baeldung.variable.scope.examples;
+
+public class BracketScopeExample {
+
+    public void mathOperationExample() {
+        Integer sum = 0;
+        {
+            Integer number = 2;
+            sum = sum + number;
+        }
+        // compiler error, number cannot be solved as a variable
+        // number++;
+    }
+}

core-java-lang/src/main/java/com/baeldung/scope/ClassScopeExample.java

@@ -0,0 +1,14 @@
+package org.baeldung.variable.scope.examples;
+
+public class ClassScopeExample {
+
+    Integer amount = 0;
+
+    public void exampleMethod() {
+        amount++;
+    }
+
+    public void anotherExampleMethod() {
+        Integer anotherAmount = amount + 4;
+    }
+}

core-java-lang/src/main/java/com/baeldung/scope/LoopScopeExample.java

@@ -0,0 +1,18 @@
+package org.baeldung.variable.scope.examples;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class LoopScopeExample {
+
+    List<String> listOfNames = Arrays.asList("Joe", "Susan", "Pattrick");
+
+    public void iterationOfNames() {
+        String allNames = "";
+        for (String name : listOfNames) {
+            allNames = allNames + " " + name;
+        }
+        // compiler error, name cannot be resolved to a variable
+        // String lastNameUsed = name;
+    }
+}

core-java-lang/src/main/java/com/baeldung/scope/MethodScopeExample.java

@@ -0,0 +1,13 @@
+package org.baeldung.variable.scope.examples;
+
+public class MethodScopeExample {
+
+    public void methodA() {
+        Integer area = 2;
+    }
+
+    public void methodB() {
+        // compiler error, area cannot be resolved to a variable
+        // area = area + 2;
+    }
+}

core-java-lang/src/main/java/com/baeldung/scope/NestedScopesExample.java

@@ -0,0 +1,12 @@
+package org.baeldung.variable.scope.examples;
+
+public class NestedScopesExample {
+
+    String title = "Baeldung";
+
+    public void printTitle() {
+        System.out.println(title);
+        String title = "John Doe";
+        System.out.println(title);
+    }
+}

core-java-lang/src/test/java/com/baeldung/objects/CarUnitTest.java

@@ -0,0 +1,38 @@
+package com.baeldung.objects;
+
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class CarUnitTest {
+    
+    private Car car;
+
+    @Before
+    public void setUp() throws Exception {
+        car = new Car("Ford", "Focus", "red");
+    }
+
+    @Test
+    public final void when_speedIncreased_then_verifySpeed() {
+        car.increaseSpeed(30);
+        assertEquals(30, car.getSpeed());
+        
+        car.increaseSpeed(20);
+        assertEquals(50, car.getSpeed());
+    }
+    
+    @Test
+    public final void when_speedDecreased_then_verifySpeed() {
+        car.increaseSpeed(50);
+        assertEquals(50, car.getSpeed());
+        
+        car.decreaseSpeed(30);
+        assertEquals(20, car.getSpeed());
+        
+        car.decreaseSpeed(20);
+        assertEquals(0, car.getSpeed());
+    }
+
+}

core-java/pom.xml

@@ -13,6 +13,7 @@
         <relativePath>../parent-java</relativePath>
     </parent>
 
+
     <dependencies>
         <dependency>
             <groupId>commons-io</groupId>

core-java/src/test/java/com/baeldung/bitwiseoperator/test/BitwiseOperatorUnitTest.java

@@ -0,0 +1,81 @@
+package com.baeldung.bitwiseoperator.test;
+
+import static org.junit.Assert.assertEquals;
+import org.junit.jupiter.api.Test;
+
+public class BitwiseOperatorUnitTest {
+
+    @Test
+    public void givenTwoIntegers_whenAndOperator_thenNewDecimalNumber() {
+        int value1 = 6;
+        int value2 = 5;
+        int result = value1 & value2;
+        assertEquals(4, result);
+    }
+
+    @Test
+    public void givenTwoIntegers_whenOrOperator_thenNewDecimalNumber() {
+        int value1 = 6;
+        int value2 = 5;
+        int result = value1 | value2;
+        assertEquals(7, result);
+    }
+
+    @Test
+    public void givenTwoIntegers_whenXorOperator_thenNewDecimalNumber() {
+        int value1 = 6;
+        int value2 = 5;
+        int result = value1 ^ value2;
+        assertEquals(3, result);
+    }
+
+    @Test
+    public void givenOneInteger_whenNotOperator_thenNewDecimalNumber() {
+        int value1 = 6;
+        int result = ~value1;
+        assertEquals(result, -7);
+    }
+
+    @Test
+    public void givenOnePositiveInteger_whenSignedRightShiftOperator_thenNewDecimalNumber() {
+        int value = 12;
+        int rightShift = value >> 2;
+        assertEquals(3, rightShift);
+    }
+
+    @Test
+    public void givenOneNegativeInteger_whenSignedRightShiftOperator_thenNewDecimalNumber() {
+        int value = -12;
+        int rightShift = value >> 2;
+        assertEquals(-3, rightShift);
+    }
+
+    @Test
+    public void givenOnePositiveInteger_whenLeftShiftOperator_thenNewDecimalNumber() {
+        int value = 12;
+        int leftShift = value << 2;
+        assertEquals(48, leftShift);
+    }
+
+    @Test
+    public void givenOneNegativeInteger_whenLeftShiftOperator_thenNewDecimalNumber() {
+        int value = -12;
+        int leftShift = value << 2;
+        assertEquals(-48, leftShift);
+    }
+
+    @Test
+    public void givenOnePositiveInteger_whenUnsignedRightShiftOperator_thenNewDecimalNumber() {
+        int value = 12;
+        int unsignedRightShift = value >>> 2;
+        assertEquals(3, unsignedRightShift);
+    }
+
+    @Test
+    public void givenOneNegativeInteger_whenUnsignedRightShiftOperator_thenNewDecimalNumber() {
+        int value = -12;
+        int unsignedRightShift = value >>> 2;
+        assertEquals(1073741821, unsignedRightShift);
+    }
+
+}

core-java/src/test/java/com/baeldung/leapyear/LeapYearUnitTest.java

@@ -1,6 +1,8 @@
 package com.baeldung.leapyear;
 
+import java.time.LocalDate;
 import java.time.Year;
+import java.time.format.DateTimeFormatter;
 import java.util.GregorianCalendar;
 
 import org.junit.Assert;

core-kotlin/src/main/kotlin/com/baeldung/forEach/forEach.kt

@@ -0,0 +1,61 @@
+package com.baeldung.forEach
+
+
+class Country(val name : String, val cities : List<City>)
+
+class City(val name : String, val streets : List<String>)
+
+class World {
+
+    private val streetsOfAmsterdam = listOf("Herengracht", "Prinsengracht")
+    private val streetsOfBerlin = listOf("Unter den Linden","Tiergarten")
+    private val streetsOfMaastricht = listOf("Grote Gracht", "Vrijthof")
+    private val countries = listOf(
+            Country("Netherlands", listOf(City("Maastricht", streetsOfMaastricht),
+                    City("Amsterdam", streetsOfAmsterdam))),
+            Country("Germany", listOf(City("Berlin", streetsOfBerlin))))
+
+    fun allCountriesIt() {
+        countries.forEach { println(it.name) }
+    }
+
+    fun allCountriesItExplicit() {
+        countries.forEach { it -> println(it.name) }
+    }
+
+    //here we cannot refer to 'it' anymore inside the forEach
+    fun allCountriesExplicit() {
+        countries.forEach { c -> println(c.name) }
+    }
+
+    fun allNested() {
+        countries.forEach {
+            println(it.name)
+            it.cities.forEach {
+                println(" ${it.name}")
+                it.streets.forEach { println("  $it") }
+            }
+        }
+    }
+
+    fun allTable() {
+        countries.forEach { c ->
+            c.cities.forEach { p ->
+                p.streets.forEach { println("${c.name} ${p.name} $it") }
+            }
+        }
+    }
+}
+
+fun main(args : Array<String>) {
+
+    val world = World()
+
+    world.allCountriesExplicit()
+
+    world.allNested()
+
+    world.allTable()
+}
+
+

core-kotlin/src/test/kotlin/com/baeldung/voidtypes/VoidTypesUnitTest.kt

@@ -0,0 +1,63 @@
+package com.baeldung.voidtypes
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class VoidTypesUnitTest {
+
+    // Un-commenting below methods will result into compilation error
+    // as the syntax used is incorrect and is used for explanation in tutorial.	
+
+    //    fun returnTypeAsVoidAttempt1(): Void {
+    //        println("Trying with Void as return type")
+    //    }
+
+    //    fun returnTypeAsVoidAttempt2(): Void {
+    //        println("Trying with Void as return type")
+    //        return null
+    //    }
+
+    fun returnTypeAsVoidSuccess(): Void? {
+        println("Function can have Void as return type")
+        return null
+    }
+
+    fun unitReturnTypeForNonMeaningfulReturns(): Unit {
+        println("No meaningful return")
+    }
+
+    fun unitReturnTypeIsImplicit() {
+        println("Unit Return type is implicit")
+    }
+
+    fun alwaysThrowException(): Nothing {
+        throw IllegalArgumentException()
+    }
+
+    fun invokeANothingOnlyFunction() {
+        alwaysThrowException()
+
+        var name = "Tom"
+    }
+
+    @Test
+    fun givenJavaVoidFunction_thenMappedToKotlinUnit() {
+        assertTrue(System.out.println() is Unit)
+    }
+
+    @Test
+    fun givenVoidReturnType_thenReturnsNullOnly() {
+        assertNull(returnTypeAsVoidSuccess())
+    }
+
+    @Test
+    fun givenUnitReturnTypeDeclared_thenReturnsOfTypeUnit() {
+        assertTrue(unitReturnTypeForNonMeaningfulReturns() is Unit)
+    }
+
+    @Test
+    fun givenUnitReturnTypeNotDeclared_thenReturnsOfTypeUnit() {
+        assertTrue(unitReturnTypeIsImplicit() is Unit)
+    }
+}

ethereum/pom.xml

@@ -37,17 +37,17 @@
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-core</artifactId>
-            <version>${springframework.version}</version>
+            <version>${spring.version}</version>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-web</artifactId>
-            <version>${springframework.version}</version>
+            <version>${spring.version}</version>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-webmvc</artifactId>
-            <version>${springframework.version}</version>
+            <version>${spring.version}</version>
         </dependency>
 
         <!-- Ethereum -->
@@ -123,12 +123,12 @@
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-context</artifactId>
-            <version>${springframework.version}</version>
+            <version>${spring.version}</version>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-test</artifactId>
-            <version>${springframework.version}</version>
+            <version>${spring.version}</version>
             <scope>test</scope>
         </dependency>
 
@@ -212,7 +212,6 @@
         <tomcat.version>8.5.4</tomcat.version>
         <ethereumj-core.version>1.5.0-RELEASE</ethereumj-core.version>
         <web3j.core.version>3.3.1</web3j.core.version>
-        <springframework.version>5.0.5.RELEASE</springframework.version>
         <spring.boot.version>1.5.6.RELEASE</spring.boot.version>
         <mockito.version>2.21.0</mockito.version>
         <jackson-databind.version>2.9.7</jackson-databind.version>

jackson/src/main/java/com/baeldung/jackson/deserialization/immutable/Employee.java

@@ -0,0 +1,24 @@
+package com.baeldung.jackson.deserialization.immutable;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+public class Employee {
+
+    private final long id;
+    private final String name;
+
+    @JsonCreator(mode = JsonCreator.Mode.PROPERTIES)
+    public Employee(@JsonProperty("id") long id, @JsonProperty("name") String name) {
+        this.id = id;
+        this.name = name;
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public String getName() {
+        return name;
+    }
+}

jackson/src/main/java/com/baeldung/jackson/deserialization/immutable/Person.java

@@ -0,0 +1,44 @@
+package com.baeldung.jackson.deserialization.immutable;
+
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonPOJOBuilder;
+
+@JsonDeserialize(builder = Person.Builder.class)
+public class Person {
+
+    private final String name;
+    private final Integer age;
+
+    private Person(String name, Integer age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Integer getAge() {
+        return age;
+    }
+
+    @JsonPOJOBuilder
+    static class Builder {
+        String name;
+        Integer age;
+
+        Builder withName(String name) {
+            this.name = name;
+            return this;
+        }
+
+        Builder withAge(Integer age) {
+            this.age = age;
+            return this;
+        }
+
+        Person build() {
+            return new Person(name, age);
+        }
+    }
+}

jackson/src/test/java/com/baeldung/jackson/deserialization/immutable/ImmutableObjectDeserializationUnitTest.java

@@ -0,0 +1,38 @@
+package com.baeldung.jackson.deserialization.immutable;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.Test;
+
+import java.io.IOException;
+
+import static org.junit.Assert.*;
+
+public class ImmutableObjectDeserializationUnitTest {
+
+    @Test
+    public void whenPublicConstructorIsUsed_thenObjectIsDeserialized() throws IOException {
+        final String json = "{\"name\":\"Frank\",\"id\":5000}";
+        Employee employee = new ObjectMapper().readValue(json, Employee.class);
+
+        assertEquals("Frank", employee.getName());
+        assertEquals(5000, employee.getId());
+    }
+
+    @Test
+    public void whenBuilderIsUsedAndFieldIsNull_thenObjectIsDeserialized() throws IOException {
+        final String json = "{\"name\":\"Frank\"}";
+        Person person = new ObjectMapper().readValue(json, Person.class);
+
+        assertEquals("Frank", person.getName());
+        assertNull(person.getAge());
+    }
+
+    @Test
+    public void whenBuilderIsUsedAndAllFieldsPresent_thenObjectIsDeserialized() throws IOException {
+        final String json = "{\"name\":\"Frank\",\"age\":50}";
+        Person person = new ObjectMapper().readValue(json, Person.class);
+
+        assertEquals("Frank", person.getName());
+        assertEquals(50, (int) person.getAge());
+    }
+}

java-collections-maps/src/test/java/com/baeldung/java/map/MultiValuedMapUnitTest.java

@@ -0,0 +1,204 @@
+package com.baeldung.java.map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.apache.commons.collections4.MultiMapUtils;
+import org.apache.commons.collections4.MultiValuedMap;
+import org.apache.commons.collections4.multimap.ArrayListValuedHashMap;
+import org.apache.commons.collections4.multimap.HashSetValuedHashMap;
+import org.junit.Test;
+
+public class MultiValuedMapUnitTest {
+
+    @Test
+    public void givenMultiValuesMap_whenPuttingMultipleValuesUsingPutMethod_thenReturningAllValues() {
+        MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
+        
+        map.put("key", "value1");
+        map.put("key", "value2");
+        map.put("key", "value2");
+        
+        assertThat((Collection<String>) map.get("key")).containsExactly("value1", "value2", "value2");
+    }
+ 
+    @Test
+    public void givenMultiValuesMap_whenPuttingMultipleValuesUsingPutAllMethod_thenReturningAllValues() {
+        MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
+        
+        map.putAll("key", Arrays.asList("value1", "value2", "value2"));
+        
+        assertThat((Collection<String>) map.get("key")).containsExactly("value1", "value2", "value2");
+    }
+
+    @Test
+    public void givenMultiValuesMap_whenGettingValueUsingGetMethod_thenReturningValue() {
+        MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
+        map.put("key", "value");
+        
+        assertThat((Collection<String>) map.get("key")).containsExactly("value");
+    }
+
+    @Test
+    public void givenMultiValuesMap_whenUsingEntriesMethod_thenReturningMappings() {
+        MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
+        map.put("key", "value1");
+        map.put("key", "value2");
+        
+        Collection<Entry<String, String>> entries = (Collection<Entry<String, String>>) map.entries();
+        
+        for(Map.Entry<String,String> entry : entries) {
+            assertThat(entry.getKey()).contains("key");
+            assertTrue(entry.getValue().equals("value1") || entry.getValue().equals("value2") );
+        }
+    }
+
+    @Test
+    public void givenMultiValuesMap_whenUsingKeysMethod_thenReturningAllKeys() {
+        MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
+        map.put("key", "value");
+        map.put("key1", "value1");
+        map.put("key2", "value2");
+        
+        assertThat(((Collection<String>) map.keys())).contains("key", "key1", "key2");
+    }
+
+    @Test
+    public void givenMultiValuesMap_whenUsingKeySetMethod_thenReturningAllKeys() {
+        MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
+        map.put("key", "value");
+        map.put("key1", "value1");
+        map.put("key2", "value2");
+        
+        assertThat((Collection<String>) map.keySet()).contains("key", "key1", "key2");
+    }
+
+    @Test
+    public void givenMultiValuesMap_whenUsingValuesMethod_thenReturningAllValues() {
+        MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
+        map.put("key", "value");
+        map.put("key1", "value1");
+        map.put("key2", "value2");
+        
+        assertThat(((Collection<String>) map.values())).contains("value", "value1", "value2");
+    }
+
+    @Test
+    public void givenMultiValuesMap_whenUsingRemoveMethod_thenReturningUpdatedMap() {
+        MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
+        map.put("key", "value");
+        map.put("key1", "value1");
+        map.put("key2", "value2");
+        assertThat(((Collection<String>) map.values())).contains("value", "value1", "value2");
+        
+        map.remove("key");
+        
+        assertThat(((Collection<String>) map.values())).contains("value1", "value2");
+    }
+
+    @Test
+    public void givenMultiValuesMap_whenUsingRemoveMappingMethod_thenReturningUpdatedMapAfterMappingRemoved() {
+        MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
+        map.put("key", "value");
+        map.put("key1", "value1");
+        map.put("key2", "value2");
+        assertThat(((Collection<String>) map.values())).contains("value", "value1", "value2");
+        
+        map.removeMapping("key", "value");
+        
+        assertThat(((Collection<String>) map.values())).contains("value1", "value2");
+    }
+
+    @Test
+    public void givenMultiValuesMap_whenUsingClearMethod_thenReturningEmptyMap() {
+        MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
+        map.put("key", "value");
+        map.put("key1", "value1");
+        map.put("key2", "value2");
+        assertThat(((Collection<String>) map.values())).contains("value", "value1", "value2");
+        
+        map.clear();
+        
+        assertTrue(map.isEmpty());
+    }
+
+    @Test
+    public void givenMultiValuesMap_whenUsingContainsKeyMethod_thenReturningTrue() {
+        MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
+        map.put("key", "value");
+        map.put("key1", "value1");
+        map.put("key2", "value2");
+        
+        assertTrue(map.containsKey("key"));
+    }
+
+    @Test
+    public void givenMultiValuesMap_whenUsingContainsValueMethod_thenReturningTrue() {
+        MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
+        map.put("key", "value");
+        map.put("key1", "value1");
+        map.put("key2", "value2");
+        
+        assertTrue(map.containsValue("value"));
+    }
+
+    @Test
+    public void givenMultiValuesMap_whenUsingIsEmptyMethod_thenReturningFalse() {
+        MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
+        map.put("key", "value");
+        map.put("key1", "value1");
+        map.put("key2", "value2");
+        
+        assertFalse(map.isEmpty());
+    }
+
+    @Test
+    public void givenMultiValuesMap_whenUsingSizeMethod_thenReturningElementCount() {
+        MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
+        map.put("key", "value");
+        map.put("key1", "value1");
+        map.put("key2", "value2");
+        
+        assertEquals(3, map.size());
+    }
+
+    @Test
+    public void givenArrayListValuedHashMap_whenPuttingDoubleValues_thenReturningAllValues() {
+        MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
+        
+        map.put("key", "value1");
+        map.put("key", "value2");
+        map.put("key", "value2");
+        
+        assertThat((Collection<String>) map.get("key")).containsExactly("value1", "value2", "value2");
+    }
+
+    @Test
+    public void givenHashSetValuedHashMap_whenPuttingTwiceTheSame_thenReturningOneValue() {
+        MultiValuedMap<String, String> map = new HashSetValuedHashMap<>();
+        
+        map.put("key1", "value1");
+        map.put("key1", "value1");
+        
+        assertThat((Collection<String>) map.get("key1")).containsExactly("value1");
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void givenUnmodifiableMultiValuedMap_whenInserting_thenThrowingException() {
+        MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
+        map.put("key", "value1");
+        map.put("key", "value2");
+        MultiValuedMap<String, String> immutableMap = MultiMapUtils.unmodifiableMultiValuedMap(map);
+        
+        immutableMap.put("key", "value3");
+    }
+    
+
+}

java-streams/src/main/java/com/baeldung/stream/filter/Customer.java

@@ -32,7 +32,7 @@ public class Customer {
         return this.points > points;
     }
 
-    public boolean hasOverThousandPoints() {
+    public boolean hasOverHundredPoints() {
         return this.points > 100;
     }
 

java-streams/src/main/java/com/baeldung/stream/sum/ArithmeticUtils.java

@@ -0,0 +1,8 @@
+package com.baeldung.stream.sum;
+
+public class ArithmeticUtils {
+
+    public static int add(int a, int b) {
+        return a + b;
+    }
+}

java-streams/src/main/java/com/baeldung/stream/sum/Item.java

@@ -0,0 +1,31 @@
+package com.baeldung.stream.sum;
+
+public class Item {
+
+    private int id;
+    private Integer price;
+
+    public Item(int id, Integer price) {
+        super();
+        this.id = id;
+        this.price = price;
+    }
+
+    // Standard getters and setters
+    public long getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public Integer getPrice() {
+        return price;
+    }
+
+    public void setPrice(Integer price) {
+        this.price = price;
+    }
+
+}

java-streams/src/main/java/com/baeldung/stream/sum/StreamSumCalculator.java

@@ -0,0 +1,59 @@
+package com.baeldung.stream.sum;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class StreamSumCalculator {
+
+    public static Integer getSumUsingCustomizedAccumulator(List<Integer> integers) {
+        return integers.stream()
+            .reduce(0, ArithmeticUtils::add);
+
+    }
+
+    public static Integer getSumUsingJavaAccumulator(List<Integer> integers) {
+        return integers.stream()
+            .reduce(0, Integer::sum);
+
+    }
+
+    public static Integer getSumUsingReduce(List<Integer> integers) {
+        return integers.stream()
+            .reduce(0, (a, b) -> a + b);
+
+    }
+
+    public static Integer getSumUsingCollect(List<Integer> integers) {
+
+        return integers.stream()
+            .collect(Collectors.summingInt(Integer::intValue));
+
+    }
+
+    public static Integer getSumUsingSum(List<Integer> integers) {
+
+        return integers.stream()
+            .mapToInt(Integer::intValue)
+            .sum();
+    }
+
+    public static Integer getSumOfMapValues(Map<Object, Integer> map) {
+
+        return map.values()
+            .stream()
+            .mapToInt(Integer::valueOf)
+            .sum();
+    }
+
+    public static Integer getSumIntegersFromString(String str) {
+
+        Integer sum = Arrays.stream(str.split(" "))
+            .filter((s) -> s.matches("\\d+"))
+            .mapToInt(Integer::valueOf)
+            .sum();
+
+        return sum;
+    }
+}

java-streams/src/main/java/com/baeldung/stream/sum/StreamSumCalculatorWithObject.java

@@ -0,0 +1,38 @@
+package com.baeldung.stream.sum;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class StreamSumCalculatorWithObject {
+
+    public static Integer getSumUsingCustomizedAccumulator(List<Item> items) {
+        return items.stream()
+            .map(x -> x.getPrice())
+            .reduce(0, ArithmeticUtils::add);
+    }
+
+    public static Integer getSumUsingJavaAccumulator(List<Item> items) {
+        return items.stream()
+            .map(x -> x.getPrice())
+            .reduce(0, Integer::sum);
+    }
+
+    public static Integer getSumUsingReduce(List<Item> items) {
+        return items.stream()
+            .map(item -> item.getPrice())
+            .reduce(0, (a, b) -> a + b);
+    }
+
+    public static Integer getSumUsingCollect(List<Item> items) {
+        return items.stream()
+            .map(x -> x.getPrice())
+            .collect(Collectors.summingInt(Integer::intValue));
+    }
+
+    public static Integer getSumUsingSum(List<Item> items) {
+        return items.stream()
+            .mapToInt(x -> x.getPrice())
+            .sum();
+    }
+
+}

java-streams/src/test/java/com/baeldung/stream/PeekUnitTest.java

@@ -0,0 +1,118 @@
+package com.baeldung.stream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.StringWriter;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class PeekUnitTest {
+
+    private StringWriter out;
+
+    @BeforeEach
+    void setup() {
+        out = new StringWriter();
+    }
+
+    @Test
+    void givenStringStream_whenCallingPeekOnly_thenNoElementProcessed() {
+        // given
+        Stream<String> nameStream = Stream.of("Alice", "Bob", "Chuck");
+
+        // when
+        nameStream.peek(out::append);
+
+        // then
+        assertThat(out.toString()).isEmpty();
+    }
+
+    @Test
+    void givenStringStream_whenCallingForEachOnly_thenElementsProcessed() {
+        // given
+        Stream<String> nameStream = Stream.of("Alice", "Bob", "Chuck");
+
+        // when
+        nameStream.forEach(out::append);
+
+        // then
+        assertThat(out.toString()).isEqualTo("AliceBobChuck");
+    }
+
+    @Test
+    void givenStringStream_whenCallingPeekAndNoopForEach_thenElementsProcessed() {
+        // given
+        Stream<String> nameStream = Stream.of("Alice", "Bob", "Chuck");
+
+        // when
+        nameStream.peek(out::append)
+            .forEach(this::noop);
+
+        // then
+        assertThat(out.toString()).isEqualTo("AliceBobChuck");
+    }
+
+    @Test
+    void givenStringStream_whenCallingPeekAndCollect_thenElementsProcessed() {
+        // given
+        Stream<String> nameStream = Stream.of("Alice", "Bob", "Chuck");
+
+        // when
+        nameStream.peek(out::append)
+            .collect(Collectors.toList());
+
+        // then
+        assertThat(out.toString()).isEqualTo("AliceBobChuck");
+    }
+
+    @Test
+    void givenStringStream_whenCallingPeekAndForEach_thenElementsProcessedTwice() {
+        // given
+        Stream<String> nameStream = Stream.of("Alice", "Bob", "Chuck");
+
+        // when
+        nameStream.peek(out::append)
+            .forEach(out::append);
+
+        // then
+        assertThat(out.toString()).isEqualTo("AliceAliceBobBobChuckChuck");
+    }
+
+    @Test
+    void givenStringStream_whenCallingPeek_thenElementsProcessedTwice() {
+        // given
+        Stream<User> userStream = Stream.of(new User("Alice"), new User("Bob"), new User("Chuck"));
+
+        // when
+        userStream.peek(u -> u.setName(u.getName().toLowerCase()))
+            .map(User::getName)
+            .forEach(out::append);
+
+        // then
+        assertThat(out.toString()).isEqualTo("alicebobchuck");
+    }
+
+    private static class User {
+        private String name;
+
+        public User(String name) {
+            this.name = name;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public void setName(String name) {
+            this.name = name;
+        }
+
+    }
+
+    private void noop(String s) {
+    }
+
+}

java-streams/src/test/java/com/baeldung/stream/filter/StreamCountUnitTest.java

@@ -0,0 +1,72 @@
+package com.baeldung.stream.filter;
+
+import org.junit.Test;
+import org.junit.Before;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class StreamCountUnitTest {
+
+    private List<Customer> customers;
+
+    @Before
+    public void setUp() {
+        Customer john = new Customer("John P.", 15, "https://images.unsplash.com/photo-1543320485-d0d5a49c2b2e");
+        Customer sarah = new Customer("Sarah M.", 200);
+        Customer charles = new Customer("Charles B.", 150);
+        Customer mary = new Customer("Mary T.", 1, "https://images.unsplash.com/photo-1543297057-25167dfc180e");
+        customers = Arrays.asList(john, sarah, charles, mary);
+    }
+
+    @Test
+    public void givenListOfCustomers_whenCount_thenGetListSize() {
+        long count = customers
+          .stream()
+          .count();
+
+        assertThat(count).isEqualTo(4L);
+    }
+
+    @Test
+    public void givenListOfCustomers_whenFilterByPointsOver100AndCount_thenGetTwo() {
+        long countBigCustomers = customers
+          .stream()
+          .filter(c -> c.getPoints() > 100)
+          .count();
+
+        assertThat(countBigCustomers).isEqualTo(2L);
+    }
+
+    @Test
+    public void givenListOfCustomers_whenFilterByPointsAndNameAndCount_thenGetOne() {
+        long count = customers
+          .stream()
+          .filter(c -> c.getPoints() > 10 && c.getName().startsWith("Charles"))
+          .count();
+
+        assertThat(count).isEqualTo(1L);
+    }
+
+    @Test
+    public void givenListOfCustomers_whenNoneMatchesFilterAndCount_thenGetZero() {
+        long count = customers
+          .stream()
+          .filter(c -> c.getPoints() > 500)
+          .count();
+
+        assertThat(count).isEqualTo(0L);
+    }
+
+    @Test
+    public void givenListOfCustomers_whenUsingMethodOverHundredPointsAndCount_thenGetTwo() {
+        long count = customers
+          .stream()
+          .filter(Customer::hasOverHundredPoints)
+          .count();
+
+        assertThat(count).isEqualTo(2L);
+    }
+}

java-streams/src/test/java/com/baeldung/stream/filter/StreamFilterUnitTest.java

@@ -62,7 +62,7 @@ public class StreamFilterUnitTest {
 
         List<Customer> customersWithMoreThan100Points = customers
           .stream()
-          .filter(Customer::hasOverThousandPoints)
+          .filter(Customer::hasOverHundredPoints)
           .collect(Collectors.toList());
 
         assertThat(customersWithMoreThan100Points).hasSize(2);
@@ -81,7 +81,7 @@ public class StreamFilterUnitTest {
           .flatMap(c -> c
             .map(Stream::of)
             .orElseGet(Stream::empty))
-          .filter(Customer::hasOverThousandPoints)
+          .filter(Customer::hasOverHundredPoints)
           .collect(Collectors.toList());
 
         assertThat(customersWithMoreThan100Points).hasSize(2);
@@ -156,4 +156,5 @@ public class StreamFilterUnitTest {
           })
           .collect(Collectors.toList())).isInstanceOf(RuntimeException.class);
     }
+    
 }

java-streams/src/test/java/com/baeldung/stream/sum/StreamSumUnitTest.java

@@ -0,0 +1,136 @@
+package com.baeldung.stream.sum;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.jupiter.api.Test;
+
+public class StreamSumUnitTest {
+
+    @Test
+    public void givenListOfIntegersWhenSummingUsingCustomizedAccumulatorThenCorrectValueReturned() {
+        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
+        Integer sum = StreamSumCalculator.getSumUsingCustomizedAccumulator(integers);
+        assertEquals(15, sum.intValue());
+
+    }
+
+    @Test
+    public void givenListOfIntegersWhenSummingUsingJavaAccumulatorThenCorrectValueReturned() {
+        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
+        Integer sum = StreamSumCalculator.getSumUsingJavaAccumulator(integers);
+        assertEquals(15, sum.intValue());
+    }
+
+    @Test
+    public void givenListOfIntegersWhenSummingUsingReduceThenCorrectValueReturned() {
+        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
+        Integer sum = StreamSumCalculator.getSumUsingReduce(integers);
+        assertEquals(15, sum.intValue());
+    }
+
+    @Test
+    public void givenListOfIntegersWhenSummingUsingCollectThenCorrectValueReturned() {
+        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
+        Integer sum = StreamSumCalculator.getSumUsingCollect(integers);
+        assertEquals(15, sum.intValue());
+    }
+
+    @Test
+    public void givenListOfIntegersWhenSummingUsingSumThenCorrectValueReturned() {
+        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
+        Integer sum = StreamSumCalculator.getSumUsingSum(integers);
+        assertEquals(15, sum.intValue());
+    }
+
+    @Test
+    public void givenListOfItemsWhenSummingUsingCustomizedAccumulatorThenCorrectValueReturned() {
+        Item item1 = new Item(1, 10);
+        Item item2 = new Item(2, 15);
+        Item item3 = new Item(3, 25);
+        Item item4 = new Item(4, 40);
+
+        List<Item> items = Arrays.asList(item1, item2, item3, item4);
+
+        Integer sum = StreamSumCalculatorWithObject.getSumUsingCustomizedAccumulator(items);
+        assertEquals(90, sum.intValue());
+
+    }
+
+    @Test
+    public void givenListOfItemsWhenSummingUsingJavaAccumulatorThenCorrectValueReturned() {
+        Item item1 = new Item(1, 10);
+        Item item2 = new Item(2, 15);
+        Item item3 = new Item(3, 25);
+        Item item4 = new Item(4, 40);
+
+        List<Item> items = Arrays.asList(item1, item2, item3, item4);
+
+        Integer sum = StreamSumCalculatorWithObject.getSumUsingJavaAccumulator(items);
+        assertEquals(90, sum.intValue());
+    }
+
+    @Test
+    public void givenListOfItemsWhenSummingUsingReduceThenCorrectValueReturned() {
+        Item item1 = new Item(1, 10);
+        Item item2 = new Item(2, 15);
+        Item item3 = new Item(3, 25);
+        Item item4 = new Item(4, 40);
+
+        List<Item> items = Arrays.asList(item1, item2, item3, item4);
+
+        Integer sum = StreamSumCalculatorWithObject.getSumUsingReduce(items);
+        assertEquals(90, sum.intValue());
+    }
+
+    @Test
+    public void givenListOfItemsWhenSummingUsingCollectThenCorrectValueReturned() {
+        Item item1 = new Item(1, 10);
+        Item item2 = new Item(2, 15);
+        Item item3 = new Item(3, 25);
+        Item item4 = new Item(4, 40);
+
+        List<Item> items = Arrays.asList(item1, item2, item3, item4);
+
+        Integer sum = StreamSumCalculatorWithObject.getSumUsingCollect(items);
+        assertEquals(90, sum.intValue());
+    }
+
+    @Test
+    public void givenListOfItemsWhenSummingUsingSumThenCorrectValueReturned() {
+        Item item1 = new Item(1, 10);
+        Item item2 = new Item(2, 15);
+        Item item3 = new Item(3, 25);
+        Item item4 = new Item(4, 40);
+
+        List<Item> items = Arrays.asList(item1, item2, item3, item4);
+
+        Integer sum = StreamSumCalculatorWithObject.getSumUsingSum(items);
+        assertEquals(90, sum.intValue());
+    }
+
+    @Test
+    public void givenMapWhenSummingThenCorrectValueReturned() {
+        Map<Object, Integer> map = new HashMap<Object, Integer>();
+        map.put(1, 10);
+        map.put(2, 15);
+        map.put(3, 25);
+        map.put(4, 40);
+
+        Integer sum = StreamSumCalculator.getSumOfMapValues(map);
+        assertEquals(90, sum.intValue());
+    }
+
+    @Test
+    public void givenStringWhenSummingThenCorrectValueReturned() {
+        String string = "Item1 10 Item2 25 Item3 30 Item4 45";
+
+        Integer sum = StreamSumCalculator.getSumIntegersFromString(string);
+        assertEquals(110, sum.intValue());
+    }
+
+}

java-strings/pom.xml

@@ -95,6 +95,12 @@
             <version>1.4</version>
         </dependency>
 
+        <dependency>
+            <groupId>org.ahocorasick</groupId>
+            <artifactId>ahocorasick</artifactId>
+            <version>0.4.0</version>
+        </dependency>
+
     </dependencies>
 
     <build>

java-strings/src/main/java/com/baeldung/string/MatchWords.java

@@ -0,0 +1,83 @@
+package com.baeldung.string;
+
+import org.ahocorasick.trie.Emit;
+import org.ahocorasick.trie.Token;
+import org.ahocorasick.trie.Trie;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class MatchWords {
+
+    public static boolean containsWordsIndexOf(String inputString, String[] words) {
+        boolean found = true;
+        for (String word : words) {
+            if (inputString.indexOf(word) == -1) {
+                found = false;
+                break;
+            }
+        }
+        return found;
+    }
+
+    public static boolean containsWords(String inputString, String[] items) {
+        boolean found = true;
+        for (String item : items) {
+            if (!inputString.contains(item)) {
+                found = false;
+                break;
+            }
+        }
+        return found;
+    }
+
+    public static boolean containsWordsAhoCorasick(String inputString, String[] words) {
+        Trie trie = Trie.builder()
+                .onlyWholeWords()
+                .addKeywords(words)
+                .build();
+
+        Collection<Emit> emits = trie.parseText(inputString);
+        emits.forEach(System.out::println);
+
+        boolean found = true;
+        for(String word : words) {
+            boolean contains = Arrays.toString(emits.toArray()).contains(word);
+            if (!contains) {
+                found = false;
+                break;
+            }
+        }
+
+        return found;
+    }
+
+    public static boolean containsWordsPatternMatch(String inputString, String[] words) {
+
+        StringBuilder regexp = new StringBuilder();
+        for (String word : words) {
+            regexp.append("(?=.*").append(word).append(")");
+        }
+
+        Pattern pattern = Pattern.compile(regexp.toString());
+
+        return pattern.matcher(inputString).find();
+    }
+
+    public static boolean containsWordsJava8(String inputString, String[] words) {
+        List<String> inputStringList = Arrays.asList(inputString.split(" "));
+        List<String> wordsList = Arrays.asList(words);
+
+        return wordsList.stream().allMatch(inputStringList::contains);
+    }
+
+    public static boolean containsWordsArray(String inputString, String[] words) {
+        List<String> inputStringList = Arrays.asList(inputString.split(" "));
+        List<String> wordsList = Arrays.asList(words);
+
+        return inputStringList.containsAll(wordsList);
+    }
+}

java-strings/src/test/java/com/baeldung/string/MatchWordsUnitTest.java

@@ -0,0 +1,66 @@
+package com.baeldung.string;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class MatchWordsUnitTest {
+
+    private final String[] words = {"hello", "Baeldung"};
+    private final String inputString = "hello there, Baeldung";
+    private final String wholeInput = "helloBaeldung";
+
+    @Test
+    public void givenText_whenCallingStringContains_shouldMatchWords() {
+        final boolean result = MatchWords.containsWords(inputString, words);
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenText_whenCallingJava8_shouldMatchWords() {
+        final boolean result = MatchWords.containsWordsJava8(inputString, words);
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenText_whenCallingJava8_shouldNotMatchWords() {
+        final boolean result = MatchWords.containsWordsJava8(wholeInput, words);
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenText_whenCallingPattern_shouldMatchWords() {
+        final boolean result = MatchWords.containsWordsPatternMatch(inputString, words);
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenText_whenCallingAhoCorasick_shouldMatchWords() {
+        final boolean result = MatchWords.containsWordsAhoCorasick(inputString, words);
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenText_whenCallingAhoCorasick_shouldNotMatchWords() {
+        final boolean result = MatchWords.containsWordsAhoCorasick(wholeInput, words);
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenText_whenCallingIndexOf_shouldMatchWords() {
+        final boolean result = MatchWords.containsWordsIndexOf(inputString, words);
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenText_whenCallingArrayList_shouldMatchWords() {
+        final boolean result = MatchWords.containsWordsArray(inputString, words);
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenText_whenCallingArrayList_shouldNotMatchWords() {
+        final boolean result = MatchWords.containsWordsArray(wholeInput, words);
+        assertThat(result).isFalse();
+    }
+}

libraries-data/README.md

@@ -15,3 +15,4 @@
 - [Intro to Apache Storm](https://www.baeldung.com/apache-storm)
 - [Guide to Ebean ORM](https://www.baeldung.com/ebean-orm)
 - [Introduction to Kafka Connectors](https://www.baeldung.com/kafka-connectors-guide)
+- [Kafka Connect Example with MQTT and MongoDB](https://www.baeldung.com/kafka-connect-mqtt-mongodb)

libraries-server/pom.xml

@@ -71,6 +71,30 @@
             <artifactId>tomcat-catalina</artifactId>
             <version>${tomcat.version}</version>
         </dependency>
+
+         <dependency>
+             <groupId>org.igniterealtime.smack</groupId>
+             <artifactId>smack-tcp</artifactId>
+             <version>${smack.version}</version>
+         </dependency>
+
+         <dependency>
+             <groupId>org.igniterealtime.smack</groupId>
+             <artifactId>smack-im</artifactId>
+             <version>${smack.version}</version>
+         </dependency>
+
+         <dependency>
+             <groupId>org.igniterealtime.smack</groupId>
+             <artifactId>smack-extensions</artifactId>
+             <version>${smack.version}</version>
+         </dependency>
+
+         <dependency>
+             <groupId>org.igniterealtime.smack</groupId>
+             <artifactId>smack-java7</artifactId>
+             <version>${smack.version}</version>
+         </dependency>
     </dependencies>
 
     <properties>
@@ -82,6 +106,7 @@
         <commons.collections.version>4.1</commons.collections.version>
         <junit.version>4.12</junit.version>
         <tomcat.version>8.5.24</tomcat.version>
+        <smack.version>4.3.1</smack.version>
     </properties>
 
 </project>

libraries-server/src/main/java/com/baeldung/smack/StanzaThread.java

@@ -0,0 +1,40 @@
+package com.baeldung.smack;
+
+import org.jivesoftware.smack.AbstractXMPPConnection;
+import org.jivesoftware.smack.chat2.Chat;
+import org.jivesoftware.smack.chat2.ChatManager;
+import org.jivesoftware.smack.tcp.XMPPTCPConnection;
+import org.jivesoftware.smack.tcp.XMPPTCPConnectionConfiguration;
+import org.jxmpp.jid.impl.JidCreate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class StanzaThread implements Runnable {
+
+    private Logger logger = LoggerFactory.getLogger(StanzaThread.class);
+
+    @Override
+    public void run() {
+        XMPPTCPConnectionConfiguration config = null;
+        try {
+            config = XMPPTCPConnectionConfiguration.builder()
+                    .setUsernameAndPassword("baeldung2","baeldung2")
+                    .setXmppDomain("jabb3r.org")
+                    .setHost("jabb3r.org")
+                    .build();
+
+            AbstractXMPPConnection connection = new XMPPTCPConnection(config);
+            connection.connect();
+            connection.login();
+
+            ChatManager chatManager = ChatManager.getInstanceFor(connection);
+
+            Chat chat = chatManager.chatWith(JidCreate.from("baeldung@jabb3r.org").asEntityBareJidOrThrow());
+
+            chat.send("Hello!");
+
+        } catch (Exception e) {
+            logger.error(e.getMessage(), e);
+        }
+    }
+}

libraries-server/src/test/java/com/baeldung/smack/SmackIntegrationTest.java

@@ -0,0 +1,85 @@
+package com.baeldung.smack;
+
+import org.jivesoftware.smack.AbstractXMPPConnection;
+import org.jivesoftware.smack.SmackException;
+import org.jivesoftware.smack.XMPPException;
+import org.jivesoftware.smack.chat2.ChatManager;
+import org.jivesoftware.smack.filter.StanzaTypeFilter;
+import org.jivesoftware.smack.packet.Message;
+import org.jivesoftware.smack.tcp.XMPPTCPConnection;
+import org.jivesoftware.smack.tcp.XMPPTCPConnectionConfiguration;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.jxmpp.stringprep.XmppStringprepException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.concurrent.CountDownLatch;
+
+public class SmackIntegrationTest {
+
+    private static AbstractXMPPConnection connection;
+    private Logger logger = LoggerFactory.getLogger(SmackIntegrationTest.class);
+
+    @BeforeClass
+    public static void setup() throws IOException, InterruptedException, XMPPException, SmackException {
+
+        XMPPTCPConnectionConfiguration config = XMPPTCPConnectionConfiguration.builder()
+                .setUsernameAndPassword("baeldung","baeldung")
+                .setXmppDomain("jabb3r.org")
+                .setHost("jabb3r.org")
+                .build();
+
+        XMPPTCPConnectionConfiguration config2 = XMPPTCPConnectionConfiguration.builder()
+                .setUsernameAndPassword("baeldung2","baeldung2")
+                .setXmppDomain("jabb3r.org")
+                .setHost("jabb3r.org")
+                .build();
+
+        connection = new XMPPTCPConnection(config);
+        connection.connect();
+        connection.login();
+
+    }
+
+    @Test
+    public void whenSendMessageWithChat_thenReceiveMessage() throws XmppStringprepException, InterruptedException {
+
+        CountDownLatch latch = new CountDownLatch(1);
+        ChatManager chatManager = ChatManager.getInstanceFor(connection);
+        final String[] expected = {null};
+
+        new StanzaThread().run();
+
+        chatManager.addIncomingListener((entityBareJid, message, chat) -> {
+            logger.info("Message arrived: " + message.getBody());
+            expected[0] = message.getBody();
+            latch.countDown();
+        });
+
+        latch.await();
+        Assert.assertEquals("Hello!", expected[0]);
+    }
+
+    @Test
+    public void whenSendMessage_thenReceiveMessageWithFilter() throws XmppStringprepException, InterruptedException {
+
+        CountDownLatch latch = new CountDownLatch(1);
+        final String[] expected = {null};
+
+        new StanzaThread().run();
+
+        connection.addAsyncStanzaListener(stanza -> {
+            if (stanza instanceof Message) {
+                Message message = (Message) stanza;
+                expected[0] = message.getBody();
+                latch.countDown();
+            }
+        }, StanzaTypeFilter.MESSAGE);
+
+        latch.await();
+        Assert.assertEquals("Hello!", expected[0]);
+    }
+}

libraries/log4j.properties

@@ -1 +1,5 @@
 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

libraries/pom.xml

@@ -675,6 +675,7 @@
             <version>${mockftpserver.version}</version>
             <scope>test</scope>
         </dependency>
+
     </dependencies>
 
     <repositories>