Merge branch 'master' into JAVA-20167_1

.gitignore

@@ -121,3 +121,6 @@ devDb*.db
 
 #jaxb
 *.xjb
+
+#neo4j
+persistence-modules/neo4j/data/**

core-java-modules/core-java-8-datetime-2/README.md

@@ -3,4 +3,5 @@
 - [Generating Random Dates in Java](https://www.baeldung.com/java-random-dates)
 - [Creating a LocalDate with Values in Java](https://www.baeldung.com/java-creating-localdate-with-values)
 - [Parsing Date Strings with Varying Formats](https://www.baeldung.com/java-parsing-dates-many-formats)
+- [How Many Days Are There in a Particular Month of a Given Year?](https://www.baeldung.com/days-particular-month-given-year)
 - [[<-- Prev]](/core-java-modules/core-java-datetime-java8-1)

core-java-modules/core-java-arrays-operations-advanced/README.md

@@ -12,3 +12,4 @@ This module contains articles about advanced operations on arrays in Java. They
 - [Concatenate Two Arrays in Java](https://www.baeldung.com/java-concatenate-arrays)
 - [Performance of System.arraycopy() vs. Arrays.copyOf()](https://www.baeldung.com/java-system-arraycopy-arrays-copyof-performance)
 - [Slicing Arrays in Java](https://www.baeldung.com/java-slicing-arrays)
+- [Combining Two or More Byte Arrays](https://www.baeldung.com/java-concatenate-byte-arrays)

core-java-modules/core-java-datetime-string-2/README.md

@@ -4,3 +4,4 @@ This module contains articles about parsing and formatting Java date and time ob
 
 ### Relevant Articles: 
 - [Convert String to Instant](https://www.baeldung.com/java-string-to-instant)
+- [Sort Date Strings in Java](https://www.baeldung.com/java-sort-date-strings)

core-java-modules/core-java-string-operations-6/README.md

@@ -2,3 +2,4 @@
 ### Relevant Articles:
 
 - [Find the Longest Word in a Given String in Java](https://www.baeldung.com/java-longest-word-string)
+- [Check if a String Is All Uppercase or Lowercase in Java](https://www.baeldung.com/java-check-string-uppercase-lowercase)

gradle-modules/gradle-7/README.md

@@ -5,3 +5,4 @@
 - [Working With Multiple Repositories in Gradle](https://www.baeldung.com/java-gradle-multiple-repositories)
 - [Different Dependency Version Declarations in Gradle](https://www.baeldung.com/gradle-different-dependency-version-declarations)
 - [Generating Javadoc With Gradle](https://www.baeldung.com/java-gradle-javadoc)
+- [Generating WSDL Stubs With Gradle](https://www.baeldung.com/java-gradle-create-wsdl-stubs)

image-compressing/README.md

@@ -1 +1,4 @@
 This module contains tutorials related to the image compression in Java.
+
+## Relevant Articles
+- [Lossy and Lossless Image Compression Using Java](https://www.baeldung.com/java-image-compression-lossy-lossless)

image-processing/pom.xml

@@ -91,10 +91,15 @@
             <artifactId>webcam-capture</artifactId>
             <version>${webcam-capture.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.openjfx</groupId>
+            <artifactId>javafx-graphics</artifactId>
+            <version>${javafx-graphics.version}</version>
+        </dependency>
     </dependencies>
 
     <properties>
-        <core-image.version>1.3.5</core-image.version>
+        <core-image.version>1.3.10</core-image.version>
         <ij.version>1.51h</ij.version>
         <imageio.version>3.3.2</imageio.version>
         <tess4j.version>4.5.1</tess4j.version>
@@ -105,6 +110,7 @@
         <imgscalr-version>4.2</imgscalr-version>
         <thumbnailator-version>0.4.11</thumbnailator-version>
         <marvin-version>1.5.5</marvin-version>
+        <javafx-graphics.version>11</javafx-graphics.version>
     </properties>
 
 </project>

jackson-modules/jackson-annotations/README.md

@@ -9,3 +9,4 @@ This module contains articles about Jackson annotations.
 - [Jackson JSON Views](https://www.baeldung.com/jackson-json-view-annotation)
 - [Deduction-Based Polymorphism in Jackson 2.12](https://www.baeldung.com/jackson-deduction-based-polymorphism)
 - [@JsonIgnore vs @Transient](https://www.baeldung.com/java-jsonignore-vs-transient)
+- [@JsonMerge Annotation in Jackson](https://www.baeldung.com/java-jsonmerge-annotation-jackson)

jmeter/README.md

@@ -56,3 +56,4 @@ Enjoy it :)
 - [Basic Authentication in JMeter](https://www.baeldung.com/jmeter-basic-auth)
 - [JMeter: Latency vs. Load Time](https://www.baeldung.com/java-jmeter-latency-vs-load-time)
 - [How Do I Generate a Dashboard Report in JMeter?](https://www.baeldung.com/jmeter-dashboard-report)
+- [Run JMeter .jmx File From the Command Line and Configure the Report File](https://www.baeldung.com/java-jmeter-command-line)

libraries-http-2/README.md

@@ -12,5 +12,6 @@ This module contains articles about HTTP libraries.
 - [Download a Binary File Using OkHttp](https://www.baeldung.com/java-okhttp-download-binary-file)
 - [Trusting a Self-Signed Certificate in OkHttp](https://www.baeldung.com/okhttp-self-signed-cert)
 - [Trusting All Certificates in OkHttp](https://www.baeldung.com/okhttp-client-trust-all-certificates)
+- [Mock a URL Connection in Java](https://www.baeldung.com/java-simulate-url-connection)
 - More articles [[<-- prev]](/libraries-http)
 

persistence-modules/neo4j/README.md

@@ -0,0 +1,15 @@
+## Spring Data Neo4j
+
+### Relevant Articles:
+- [A Guide to Neo4J with Java](https://www.baeldung.com/java-neo4j)
+
+### Build the Project with Tests Running
+```
+mvn clean install
+```
+
+### Run Tests Directly
+```
+mvn test
+```
+

persistence-modules/neo4j/pom.xml

@@ -0,0 +1,117 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>neo4j</artifactId>
+    <version>1.0</version>
+    <name>neo4j</name>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>persistence-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j</artifactId>
+            <version>${neo4j.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-ogm-core</artifactId>
+            <version>${neo4j-ogm-core.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-ogm-embedded-driver</artifactId>
+            <version>${neo4j-ogm-embedded.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-ogm-bolt-driver</artifactId>
+            <version>${neo4j-ogm-bolt-driver.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.neo4j.driver</groupId>
+            <artifactId>neo4j-java-driver</artifactId>
+            <version>${neo4j-java-driver.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-jdbc-driver</artifactId>
+            <version>${neo4j-jdbc.version}</version>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.voodoodyne.jackson.jsog</groupId>
+            <artifactId>jackson-jsog</artifactId>
+            <version>${jackson-jsog.version}</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-kernel</artifactId>
+            <version>${neo4j.version}</version>
+            <type>test-jar</type>
+        </dependency>
+        <dependency>
+            <groupId>org.neo4j.app</groupId>
+            <artifactId>neo4j-server</artifactId>
+            <version>${neo4j.version}</version>
+            <type>test-jar</type>
+            <exclusions>
+                <exclusion>
+                    <artifactId>commons-logging</artifactId>
+                    <groupId>commons-logging</groupId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-ogm-test</artifactId>
+            <version>${neo4j-ogm.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.neo4j.test</groupId>
+            <artifactId>neo4j-harness</artifactId>
+            <version>${neo4j.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>neo4j</artifactId>
+            <version>${testcontainers.version}</version>
+            <scope>test</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.jetbrains</groupId>
+                    <artifactId>annotations</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.apache.commons</groupId>
+                    <artifactId>commons-compress</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>javax.xml.bind</groupId>
+                    <artifactId>jaxb-api</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <neo4j-java-driver.version>5.6.0</neo4j-java-driver.version>
+        <neo4j.version>5.8.0</neo4j.version>
+        <jackson-jsog.version>1.1.2</jackson-jsog.version>
+        <neo4j-ogm.version>3.1.22</neo4j-ogm.version>
+        <neo4j-ogm-core.version>4.0.5</neo4j-ogm-core.version>
+        <neo4j-ogm-embedded.version>3.2.39</neo4j-ogm-embedded.version>
+        <neo4j-jdbc.version>4.0.9</neo4j-jdbc.version>
+        <neo4j-ogm-bolt-driver.version>4.0.5</neo4j-ogm-bolt-driver.version>
+    </properties>
+
+</project>

persistence-modules/neo4j/src/main/java/com/baeldung/neo4j/domain/Car.java

@@ -0,0 +1,50 @@
+package com.baeldung.neo4j.domain;
+
+import static org.neo4j.ogm.annotation.Relationship.Direction.INCOMING;
+
+import org.neo4j.ogm.annotation.GeneratedValue;
+import org.neo4j.ogm.annotation.Id;
+import org.neo4j.ogm.annotation.NodeEntity;
+import org.neo4j.ogm.annotation.Relationship;
+
+@NodeEntity
+public class Car {
+    @Id @GeneratedValue
+    private Long id;
+
+    private String make;
+
+    @Relationship(direction = INCOMING)
+    private Company company;
+
+    public Car(String make, String model) {
+        this.make = make;
+        this.model = model;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getMake() {
+        return make;
+    }
+
+    public void setMake(String make) {
+        this.make = make;
+    }
+
+    public String getModel() {
+        return model;
+    }
+
+    public void setModel(String model) {
+        this.model = model;
+    }
+
+    private String model;
+}

persistence-modules/neo4j/src/main/java/com/baeldung/neo4j/domain/Company.java

@@ -0,0 +1,42 @@
+package com.baeldung.neo4j.domain;
+
+import org.neo4j.ogm.annotation.NodeEntity;
+import org.neo4j.ogm.annotation.Relationship;
+
+@NodeEntity
+public class Company {
+    private Long id;
+
+    private String name;
+
+    @Relationship(type="owns")
+    private Car car;
+
+    public Company(String name) {
+        this.name = name;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Car getCar() {
+        return car;
+    }
+
+    public void setCar(Car car) {
+        this.car = car;
+    }
+}

persistence-modules/neo4j/src/main/java/com/baeldung/neo4j/domain/Movie.java

@@ -0,0 +1,66 @@
+package com.baeldung.neo4j.domain;
+
+import static org.neo4j.ogm.annotation.Relationship.Direction.INCOMING;
+
+import com.fasterxml.jackson.annotation.JsonIdentityInfo;
+import com.voodoodyne.jackson.jsog.JSOGGenerator;
+
+import org.neo4j.ogm.annotation.GeneratedValue;
+import org.neo4j.ogm.annotation.Id;
+import org.neo4j.ogm.annotation.NodeEntity;
+import org.neo4j.ogm.annotation.Relationship;
+
+import java.util.Collection;
+import java.util.List;
+
+@JsonIdentityInfo(generator = JSOGGenerator.class)
+
+@NodeEntity
+public class Movie {
+    @Id @GeneratedValue
+    Long id;
+
+    private String title;
+
+    private int released;
+    private String tagline;
+
+    @Relationship(type = "ACTED_IN", direction = INCOMING)
+    private List<Role> roles;
+
+    public Movie() {
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public int getReleased() {
+        return released;
+    }
+
+    public String getTagline() {
+        return tagline;
+    }
+
+    public Collection<Role> getRoles() {
+        return roles;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public void setReleased(int released) {
+        this.released = released;
+    }
+
+    public void setTagline(String tagline) {
+        this.tagline = tagline;
+    }
+
+    public void setRoles(List<Role> roles) {
+        this.roles = roles;
+    }
+
+}

persistence-modules/neo4j/src/main/java/com/baeldung/neo4j/domain/Person.java

@@ -0,0 +1,52 @@
+package com.baeldung.neo4j.domain;
+
+import com.fasterxml.jackson.annotation.JsonIdentityInfo;
+import com.voodoodyne.jackson.jsog.JSOGGenerator;
+
+import org.neo4j.ogm.annotation.GeneratedValue;
+import org.neo4j.ogm.annotation.Id;
+import org.neo4j.ogm.annotation.NodeEntity;
+import org.neo4j.ogm.annotation.Relationship;
+
+import java.util.List;
+
+@JsonIdentityInfo(generator = JSOGGenerator.class)
+@NodeEntity
+public class Person {
+    @Id @GeneratedValue
+    Long id;
+
+    private String name;
+    private int born;
+
+    @Relationship(type = "ACTED_IN")
+    private List<Movie> movies;
+
+    public Person() {
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getBorn() {
+        return born;
+    }
+
+    public List<Movie> getMovies() {
+        return movies;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setBorn(int born) {
+        this.born = born;
+    }
+
+    public void setMovies(List<Movie> movies) {
+        this.movies = movies;
+    }
+
+}

persistence-modules/neo4j/src/main/java/com/baeldung/neo4j/domain/Role.java

@@ -0,0 +1,50 @@
+package com.baeldung.neo4j.domain;
+
+import com.fasterxml.jackson.annotation.JsonIdentityInfo;
+import com.voodoodyne.jackson.jsog.JSOGGenerator;
+import org.neo4j.ogm.annotation.EndNode;
+import org.neo4j.ogm.annotation.GeneratedValue;
+import org.neo4j.ogm.annotation.Id;
+import org.neo4j.ogm.annotation.RelationshipEntity;
+import org.neo4j.ogm.annotation.StartNode;
+
+import java.util.Collection;
+
+@JsonIdentityInfo(generator = JSOGGenerator.class)
+@RelationshipEntity(type = "ACTED_IN")
+public class Role {
+    @Id @GeneratedValue
+	Long id;
+    private Collection<String> roles;
+    @StartNode
+    private Person person;
+    @EndNode
+    private Movie movie;
+
+    public Role() {
+    }
+
+    public Collection<String> getRoles() {
+        return roles;
+    }
+
+    public Person getPerson() {
+        return person;
+    }
+
+    public Movie getMovie() {
+        return movie;
+    }
+
+    public void setRoles(Collection<String> roles) {
+        this.roles = roles;
+    }
+
+    public void setPerson(Person person) {
+        this.person = person;
+    }
+
+    public void setMovie(Movie movie) {
+        this.movie = movie;
+    }
+}

persistence-modules/neo4j/src/test/java/com/baeldung/neo4j/Neo4JServerLiveTest.java

@@ -0,0 +1,79 @@
+package com.baeldung.neo4j;
+
+import static com.baeldung.neo4j.TestContainersTestBase.DEFAULT_PASSWORD;
+import static com.baeldung.neo4j.TestContainersTestBase.getNewBoltConnection;
+import static com.baeldung.neo4j.TestContainersTestBase.neo4jServer;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.Statement;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.neo4j.driver.Driver;
+import org.neo4j.driver.Result;
+import org.neo4j.driver.Session;
+
+
+/**
+ * To run this test you will need to have an instance of the docker running on your machine (Docker desktop - for Windows and Docker instance for linux)
+ * After your docker instance is up run this test
+ */
+class Neo4JServerLiveTest {
+
+    private static Session session;
+    private static Driver driver;
+
+    @BeforeAll
+    public static void setup() {
+        driver = getNewBoltConnection();
+    }
+
+    @AfterAll
+    public static void tearDown() {
+        driver.close();
+    }
+
+    @Test
+    void standAloneDriver() {
+        session = driver.session();
+        session.run("CREATE (baeldung:Company {name:\"Baeldung\"}) " +
+                "-[:owns]-> (tesla:Car {make: 'tesla', model: 'modelX'})" +
+                "RETURN baeldung, tesla");
+
+        Result result = session.run("MATCH (company:Company)-[:owns]-> (car:Car)" +
+                "WHERE car.make='tesla' and car.model='modelX'" +
+                "RETURN company.name");
+
+        assertTrue(result.hasNext());
+        assertEquals("Baeldung", result.next().get("company.name").asString());
+
+        session.close();
+    }
+
+    @Test
+    void standAloneJdbc() throws Exception {
+        String uri = "jdbc:neo4j:" + neo4jServer.getBoltUrl() + "/?user=neo4j,password=" + DEFAULT_PASSWORD + ",scheme=basic";
+        Connection con = DriverManager.getConnection(uri);
+
+        // Querying
+        try (Statement stmt = con.createStatement()) {
+            stmt.execute("CREATE (baeldung:Company {name:\"Baeldung\"}) " +
+                    "-[:owns]-> (tesla:Car {make: 'tesla', model: 'modelX'})" +
+                    "RETURN baeldung, tesla");
+
+            ResultSet rs = stmt.executeQuery("MATCH (company:Company)-[:owns]-> (car:Car)" +
+                    "WHERE car.make='tesla' and car.model='modelX'" +
+                    "RETURN company.name");
+
+            while (rs.next()) {
+                assertEquals("Baeldung", rs.getString("company.name"));
+            }
+        }
+        con.close();
+    }
+}

persistence-modules/neo4j/src/test/java/com/baeldung/neo4j/Neo4jLiveTest.java

@@ -1,7 +1,10 @@
 package com.baeldung.neo4j;
 
 
+import static org.neo4j.configuration.GraphDatabaseSettings.DEFAULT_DATABASE_NAME;
+
 import java.io.File;
+import java.time.Duration;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
@@ -10,101 +13,111 @@ import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.neo4j.configuration.GraphDatabaseSettings;
+import org.neo4j.dbms.api.DatabaseManagementService;
+import org.neo4j.dbms.api.DatabaseManagementServiceBuilder;
 import org.neo4j.graphdb.GraphDatabaseService;
 import org.neo4j.graphdb.Label;
 import org.neo4j.graphdb.Node;
 import org.neo4j.graphdb.NotFoundException;
 import org.neo4j.graphdb.RelationshipType;
 import org.neo4j.graphdb.Result;
-import org.neo4j.graphdb.factory.GraphDatabaseFactory;
+import org.neo4j.graphdb.Transaction;
 
+/**
+ * To run this test you will need to have an instance of the docker running on your machine (Docker desktop - for Windows and Docker instance for linux)
+ * After your docker instance is up run this test
+ */
 public class Neo4jLiveTest {
 
     private static GraphDatabaseService graphDb;
+    private static Transaction transaction;
+    private static DatabaseManagementService managementService;
 
     @Before
     public void setUp() {
-        GraphDatabaseFactory graphDbFactory = new GraphDatabaseFactory();
+        managementService = new DatabaseManagementServiceBuilder(new File("data/cars").toPath())
-        graphDb = graphDbFactory.newEmbeddedDatabase(new File("data/cars"));
+                .setConfig( GraphDatabaseSettings.transaction_timeout, Duration.ofSeconds( 60 ) )
+                .setConfig( GraphDatabaseSettings.preallocate_logical_logs, false ).build();
+        graphDb = managementService.database( DEFAULT_DATABASE_NAME );
     }
 
     @After
     public void tearDown() {
-        graphDb.shutdown();
+        managementService.shutdown();
     }
 
     @Test
     public void testPersonCar() {
-        graphDb.beginTx();
+        transaction = graphDb.beginTx();
-        Node car = graphDb.createNode(Label.label("Car"));
+        Node car = transaction.createNode(Label.label("Car"));
         car.setProperty("make", "tesla");
         car.setProperty("model", "model3");
 
-        Node owner = graphDb.createNode(Label.label("Person"));
+        Node owner = transaction.createNode(Label.label("Person"));
         owner.setProperty("firstName", "baeldung");
         owner.setProperty("lastName", "baeldung");
 
         owner.createRelationshipTo(car, RelationshipType.withName("owner"));
 
-        Result result = graphDb.execute("MATCH (c:Car) <-[owner]- (p:Person) " +
+        Result result = transaction.execute("MATCH (c:Car) <-[owner]- (p:Person) " +
                 "WHERE c.make = 'tesla'" +
                 "RETURN p.firstName, p.lastName");
 
         Map<String, Object> firstResult = result.next();
+
         Assert.assertEquals("baeldung", firstResult.get("p.firstName"));
     }
 
     @Test
     public void testCreateNode() {
-
+        transaction = graphDb.beginTx();
-        graphDb.beginTx();
+        Result result = transaction.execute("CREATE (baeldung:Company {name:\"Baeldung\"})" +
-
-        Result result = graphDb.execute("CREATE (baeldung:Company {name:\"Baeldung\"})" +
                 "RETURN baeldung");
 
         Map<String, Object> firstResult = result.next();
         Node firstNode = (Node) firstResult.get("baeldung");
+
         Assert.assertEquals(firstNode.getProperty("name"), "Baeldung");
     }
 
     @Test
     public void testCreateNodeAndLink() {
-        graphDb.beginTx();
+        transaction = graphDb.beginTx();
-
+        Result result = transaction.execute("CREATE (baeldung:Company {name:\"Baeldung\"}) " +
-        Result result = graphDb.execute("CREATE (baeldung:Company {name:\"Baeldung\"}) " +
                 "-[:owns]-> (tesla:Car {make: 'tesla', model: 'modelX'})" +
                 "RETURN baeldung, tesla");
 
         Map<String, Object> firstResult = result.next();
+
         Assert.assertTrue(firstResult.containsKey("baeldung"));
         Assert.assertTrue(firstResult.containsKey("tesla"));
     }
 
     @Test
     public void testFindAndReturn() {
-        graphDb.beginTx();
+        transaction = graphDb.beginTx();
-
+        transaction.execute("CREATE (baeldung:Company {name:\"Baeldung\"}) " +
-        graphDb.execute("CREATE (baeldung:Company {name:\"Baeldung\"}) " +
                 "-[:owns]-> (tesla:Car {make: 'tesla', model: 'modelX'})" +
                 "RETURN baeldung, tesla");
 
-        Result result = graphDb.execute("MATCH (company:Company)-[:owns]-> (car:Car)" +
+        Result result = transaction.execute("MATCH (company:Company)-[:owns]-> (car:Car)" +
                 "WHERE car.make='tesla' and car.model='modelX'" +
                 "RETURN company.name");
 
         Map<String, Object> firstResult = result.next();
+
         Assert.assertEquals(firstResult.get("company.name"), "Baeldung");
     }
 
     @Test
     public void testUpdate() {
-        graphDb.beginTx();
+        transaction = graphDb.beginTx();
-
+        transaction.execute("CREATE (baeldung:Company {name:\"Baeldung\"}) " +
-        graphDb.execute("CREATE (baeldung:Company {name:\"Baeldung\"}) " +
                 "-[:owns]-> (tesla:Car {make: 'tesla', model: 'modelX'})" +
                 "RETURN baeldung, tesla");
 
-        Result result = graphDb.execute("MATCH (car:Car)" +
+        Result result = transaction.execute("MATCH (car:Car)" +
                 "WHERE car.make='tesla'" +
                 " SET car.milage=120" +
                 " SET car :Car:Electro" +
@@ -127,17 +140,16 @@ public class Neo4jLiveTest {
 
     @Test
     public void testDelete() {
-        graphDb.beginTx();
+        transaction = graphDb.beginTx();
-
+        transaction.execute("CREATE (baeldung:Company {name:\"Baeldung\"}) " +
-        graphDb.execute("CREATE (baeldung:Company {name:\"Baeldung\"}) " +
                 "-[:owns]-> (tesla:Car {make: 'tesla', model: 'modelX'})" +
                 "RETURN baeldung, tesla");
 
-        graphDb.execute("MATCH (company:Company)" +
+        transaction.execute("MATCH (company:Company)" +
                 " WHERE company.name='Baeldung'" +
                 " DELETE company");
 
-        Result result = graphDb.execute("MATCH (company:Company)" +
+        Result result = transaction.execute("MATCH (company:Company)" +
                 " WHERE company.name='Baeldung'" +
                 " RETURN company");
 
@@ -146,14 +158,13 @@ public class Neo4jLiveTest {
 
     @Test
     public void testBindings() {
-        graphDb.beginTx();
+        transaction = graphDb.beginTx();
-
         Map<String, Object> params = new HashMap<>();
         params.put("name", "baeldung");
         params.put("make", "tesla");
         params.put("model", "modelS");
 
-        Result result = graphDb.execute("CREATE (baeldung:Company {name:$name}) " +
+        Result result = transaction.execute("CREATE (baeldung:Company {name:$name}) " +
                 "-[:owns]-> (tesla:Car {make: $make, model: $model})" +
                 "RETURN baeldung, tesla", params);
 

persistence-modules/neo4j/src/test/java/com/baeldung/neo4j/Neo4jOgmLiveTest.java

@@ -0,0 +1,58 @@
+package com.baeldung.neo4j;
+
+import static com.baeldung.neo4j.TestContainersTestBase.getDriver;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.neo4j.ogm.model.Result;
+import org.neo4j.ogm.session.Session;
+import org.neo4j.ogm.session.SessionFactory;
+
+import com.baeldung.neo4j.domain.Car;
+import com.baeldung.neo4j.domain.Company;
+
+/**
+ * To run this test you will need to have an instance of the docker running on your machine (Docker desktop - for Windows and Docker instance for linux)
+ * After your docker instance is up run this test
+ */
+public class Neo4jOgmLiveTest {
+
+    private static SessionFactory sessionFactory;
+    private static Session session;
+
+    @BeforeAll
+    public static void oneTimeSetUp() {
+        sessionFactory = new SessionFactory(getDriver(), "com.baeldung.neo4j.domain");
+        session = sessionFactory.openSession();
+        session.purgeDatabase();
+    }
+
+    @Test
+    void testOgm() {
+        Car tesla = new Car("tesla", "modelS");
+        Company baeldung = new Company("baeldung");
+
+        baeldung.setCar(tesla);
+
+        session.save(baeldung);
+
+        assertEquals(1, session.countEntitiesOfType(Company.class));
+
+        Map<String, String> params = new HashMap<>();
+        params.put("make", "tesla");
+        Result result = session.query("MATCH (car:Car) <-[:owns]- (company:Company)" +
+                " WHERE car.make=$make" +
+                " RETURN company", params);
+
+        Map<String, Object> firstResult = result.iterator().next();
+
+        assertEquals(1, firstResult.size());
+
+        Company actual = (Company) firstResult.get("company");
+        assertEquals(actual.getName(), baeldung.getName());
+    }
+}

persistence-modules/neo4j/src/test/java/com/baeldung/neo4j/TestContainersTestBase.java

@@ -0,0 +1,132 @@
+package com.baeldung.neo4j;
+
+import static org.neo4j.ogm.drivers.bolt.driver.BoltDriver.CONFIG_PARAMETER_BOLT_LOGGING;
+
+import java.util.Locale;
+import java.util.Optional;
+
+import org.neo4j.driver.AccessMode;
+import org.neo4j.driver.AuthTokens;
+import org.neo4j.driver.GraphDatabase;
+import org.neo4j.driver.Logging;
+import org.neo4j.driver.Session;
+import org.neo4j.driver.SessionConfig;
+import org.neo4j.ogm.config.Configuration;
+import org.neo4j.ogm.driver.Driver;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.testcontainers.containers.Neo4jContainer;
+import org.testcontainers.utility.TestcontainersConfiguration;
+
+/**
+ * Reference: https://github.com/neo4j/neo4j-ogm/blob/master/neo4j-ogm-tests/neo4j-ogm-integration-tests/src/test/java/org/neo4j/ogm/testutil/TestContainersTestBase.java
+ */
+public class TestContainersTestBase {
+
+    public static final Logger LOGGER = LoggerFactory.getLogger(TestContainersTestBase.class);
+
+    public static final Driver driver;
+
+    public static final String version;
+
+    public static final String DEFAULT_IMAGE = "neo4j:5";
+
+    public static final String SYS_PROPERTY_ACCEPT_AND_USE_COMMERCIAL_EDITION = "NEO4J_OGM_NEO4J_ACCEPT_AND_USE_COMMERCIAL_EDITION";
+
+    public static final String SYS_PROPERTY_IMAGE_NAME = "NEO4J_OGM_NEO4J_IMAGE_NAME";
+
+    public static final String SYS_PROPERTY_NEO4J_URL = "NEO4J_OGM_NEO4J_URL";
+
+    public static final String SYS_PROPERTY_NEO4J_PASSWORD = "NEO4J_OGM_NEO4J_PASSWORD";
+
+    public static final String DEFAULT_PASSWORD = "12345";
+
+    public static Neo4jContainer neo4jServer;
+
+    public static Configuration.Builder baseConfigurationBuilder;
+
+    public static final String NEO4J_URL = Optional.ofNullable(System.getenv(SYS_PROPERTY_NEO4J_URL)).orElse("");
+
+    public static final String NEO4J_PASSWORD = Optional.ofNullable(System.getenv(SYS_PROPERTY_NEO4J_PASSWORD)).orElse("").trim();
+
+    static {
+
+        boolean acceptAndUseCommercialEdition = hasAcceptedAndWantsToUseCommercialEdition();
+
+        if (!(NEO4J_URL.isEmpty() || NEO4J_PASSWORD.isEmpty())) {
+            LOGGER.info("Using Neo4j instance at {}.", NEO4J_URL);
+            driver = new org.neo4j.ogm.drivers.bolt.driver.BoltDriver();
+            baseConfigurationBuilder = new Configuration.Builder()
+                .uri(NEO4J_URL)
+                .verifyConnection(true)
+                .withCustomProperty(CONFIG_PARAMETER_BOLT_LOGGING, Logging.slf4j())
+                .credentials("neo4j", NEO4J_PASSWORD);
+            driver.configure(baseConfigurationBuilder.build());
+            version = extractVersionFromBolt();
+        } else {
+            LOGGER.info("Using Neo4j test container.");
+            String imageName = Optional.ofNullable(System.getenv(SYS_PROPERTY_IMAGE_NAME))
+                .orElse(DEFAULT_IMAGE + (acceptAndUseCommercialEdition ? "-enterprise" : ""));
+
+            version = extractVersionFromDockerImage(imageName);
+
+            boolean containerReuseSupported = TestcontainersConfiguration
+                .getInstance().environmentSupportsReuse();
+            neo4jServer = new Neo4jContainer<>(imageName)
+                    .withReuse(containerReuseSupported);
+
+            if (acceptAndUseCommercialEdition) {
+                neo4jServer.withEnv("NEO4J_ACCEPT_LICENSE_AGREEMENT", "yes");
+            }
+            neo4jServer.withAdminPassword(DEFAULT_PASSWORD).start();
+
+            driver = new org.neo4j.ogm.drivers.bolt.driver.BoltDriver();
+
+            baseConfigurationBuilder = new Configuration.Builder()
+                .uri(neo4jServer.getBoltUrl())
+                .credentials("neo4j", DEFAULT_PASSWORD)
+                .verifyConnection(true)
+                .withCustomProperty(CONFIG_PARAMETER_BOLT_LOGGING, Logging.slf4j());
+
+            driver.configure(baseConfigurationBuilder.build());
+
+            Runtime.getRuntime().addShutdownHook(new Thread(neo4jServer::stop));
+        }
+    }
+
+    public static org.neo4j.driver.Driver getNewBoltConnection() {
+
+        if (neo4jServer != null) {
+            return GraphDatabase.driver(neo4jServer.getBoltUrl(), AuthTokens.basic("neo4j", DEFAULT_PASSWORD));
+        } else {
+            return GraphDatabase.driver(NEO4J_URL, AuthTokens.basic("neo4j", NEO4J_PASSWORD));
+        }
+    }
+
+    public static boolean hasAcceptedAndWantsToUseCommercialEdition() {
+        return Optional.ofNullable(
+            System.getenv(TestContainersTestBase.SYS_PROPERTY_ACCEPT_AND_USE_COMMERCIAL_EDITION))
+            .orElse("no").toLowerCase(Locale.ENGLISH).equals("yes");
+    }
+
+    public static Driver getDriver() {
+        return driver;
+    }
+
+    private static String extractVersionFromDockerImage(String imageName) {
+        return imageName.replace("neo4j:", "").replace("neo4j/neo4j-experimental:", "").replace("-enterprise", "");
+    }
+
+    private static String extractVersionFromBolt() {
+
+        org.neo4j.driver.Driver driver = getDriver().unwrap(org.neo4j.driver.Driver.class);
+
+        String version;
+        SessionConfig sessionConfig = SessionConfig.builder().withDefaultAccessMode(AccessMode.READ).build();
+        try (Session session = driver.session(sessionConfig)) {
+            version = (String) session.run("CALL dbms.components() YIELD versions").single().get("versions").asList().get(0);
+        }
+        return version.toLowerCase(Locale.ENGLISH);
+    }
+
+}

persistence-modules/pom.xml

@@ -110,6 +110,7 @@
         <module>spring-data-rest</module>
         <module>java-mongodb</module>
         <module>questdb</module>
+        <module>neo4j</module>
     </modules>
 
     <properties>

persistence-modules/spring-data-elasticsearch/README.md

@@ -6,6 +6,7 @@
 - [Guide to Elasticsearch in Java](https://www.baeldung.com/elasticsearch-java)
 - [Geospatial Support in ElasticSearch](https://www.baeldung.com/elasticsearch-geo-spatial)
 - [A Simple Tagging Implementation with Elasticsearch](https://www.baeldung.com/elasticsearch-tagging)
+- [What Is Elasticsearch?](https://www.baeldung.com/java-elasticsearch)
 
 ### Build the Project with Tests Running
 ```

persistence-modules/spring-data-neo4j/pom.xml

@@ -14,26 +14,11 @@
     </parent>
 
     <dependencies>
-        <dependency>
-            <groupId>org.neo4j</groupId>
-            <artifactId>neo4j</artifactId>
-            <version>${neo4j.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.neo4j</groupId>
-            <artifactId>neo4j-ogm-core</artifactId>
-            <version>${neo4j-ogm.version}</version>
-        </dependency>
         <dependency>
             <groupId>org.neo4j</groupId>
             <artifactId>neo4j-ogm-embedded-driver</artifactId>
             <version>${neo4j-ogm.version}</version>
         </dependency>
-        <dependency>
-            <groupId>org.neo4j.driver</groupId>
-            <artifactId>neo4j-java-driver</artifactId>
-            <version>${neo4j-java-driver.version}</version>
-        </dependency>
         <dependency>
             <groupId>org.springframework.data</groupId>
             <artifactId>spring-data-neo4j</artifactId>
@@ -51,24 +36,6 @@
             <version>${spring-boot.version}</version>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>org.neo4j</groupId>
-            <artifactId>neo4j-kernel</artifactId>
-            <version>${neo4j.version}</version>
-            <type>test-jar</type>
-        </dependency>
-        <dependency>
-            <groupId>org.neo4j.app</groupId>
-            <artifactId>neo4j-server</artifactId>
-            <version>${neo4j.version}</version>
-            <type>test-jar</type>
-            <exclusions>
-                <exclusion>
-                    <artifactId>commons-logging</artifactId>
-                    <groupId>commons-logging</groupId>
-                </exclusion>
-            </exclusions>
-        </dependency>
         <dependency>
             <groupId>org.neo4j</groupId>
             <artifactId>neo4j-ogm-test</artifactId>
@@ -89,7 +56,6 @@
     </dependencies>
 
     <properties>
-        <neo4j-java-driver.version>1.6.2</neo4j-java-driver.version>
         <neo4j.version>3.4.6</neo4j.version>
         <spring-data-neo4j.version>5.0.1.RELEASE</spring-data-neo4j.version>
         <jackson-jsog.version>1.1</jackson-jsog.version>

persistence-modules/spring-data-neo4j/src/test/java/com/baeldung/neo4j/Neo4JServerLiveTest.java

@@ -1,60 +0,0 @@
-package com.baeldung.neo4j;
-
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.ResultSet;
-import java.sql.Statement;
-
-import org.junit.Assert;
-import org.junit.Ignore;
-import org.junit.Test;
-import org.neo4j.driver.v1.AuthTokens;
-import org.neo4j.driver.v1.Driver;
-import org.neo4j.driver.v1.GraphDatabase;
-import org.neo4j.driver.v1.Session;
-import org.neo4j.driver.v1.StatementResult;
-
-@Ignore
-public class Neo4JServerLiveTest {
-
-    @Test
-    public void standAloneDriver() {
-        Driver driver = GraphDatabase.driver("bolt://localhost:7687", AuthTokens.basic("neo4j", "12345"));
-        Session session = driver.session();
-
-        session.run("CREATE (baeldung:Company {name:\"Baeldung\"}) " +
-                "-[:owns]-> (tesla:Car {make: 'tesla', model: 'modelX'})" +
-                "RETURN baeldung, tesla");
-
-        StatementResult result = session.run("MATCH (company:Company)-[:owns]-> (car:Car)" +
-                "WHERE car.make='tesla' and car.model='modelX'" +
-                "RETURN company.name");
-
-        Assert.assertTrue(result.hasNext());
-        Assert.assertEquals(result.next().get("company.name").asString(), "Baeldung");
-
-        session.close();
-        driver.close();
-    }
-    
-    @Test
-    public void standAloneJdbc() throws Exception {
-        Connection con = DriverManager.getConnection("jdbc:neo4j:bolt://localhost/?user=neo4j,password=12345,scheme=basic");
-
-        // Querying
-        try (Statement stmt = con.createStatement()) {
-            stmt.execute("CREATE (baeldung:Company {name:\"Baeldung\"}) " +
-                    "-[:owns]-> (tesla:Car {make: 'tesla', model: 'modelX'})" +
-                    "RETURN baeldung, tesla");
-
-            ResultSet rs = stmt.executeQuery("MATCH (company:Company)-[:owns]-> (car:Car)" +
-                    "WHERE car.make='tesla' and car.model='modelX'" +
-                    "RETURN company.name");
-
-            while (rs.next()) {
-                Assert.assertEquals(rs.getString("company.name"), "Baeldung");
-            }
-        }
-        con.close();
-    }
-}

persistence-modules/spring-data-neo4j/src/test/java/com/baeldung/neo4j/Neo4jOgmLiveTest.java

@@ -1,47 +0,0 @@
-package com.baeldung.neo4j;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import org.junit.Assert;
-import org.junit.Test;
-import org.neo4j.ogm.config.Configuration;
-import org.neo4j.ogm.model.Result;
-import org.neo4j.ogm.session.Session;
-import org.neo4j.ogm.session.SessionFactory;
-
-import com.baeldung.spring.data.neo4j.domain.Car;
-import com.baeldung.spring.data.neo4j.domain.Company;
-
-public class Neo4jOgmLiveTest {
-
-    @Test
-    public void testOgm() {
-        Configuration conf = new Configuration.Builder().build();
-
-        SessionFactory factory = new SessionFactory(conf, "com.baeldung.spring.data.neo4j.domain");
-        Session session = factory.openSession();
-
-        Car tesla = new Car("tesla", "modelS");
-        Company baeldung = new Company("baeldung");
-
-        baeldung.setCar(tesla);
-
-        session.save(baeldung);
-
-        Assert.assertEquals(1, session.countEntitiesOfType(Company.class));
-
-        Map<String, String> params = new HashMap<>();
-        params.put("make", "tesla");
-        Result result = session.query("MATCH (car:Car) <-[:owns]- (company:Company)" +
-                " WHERE car.make=$make" +
-                " RETURN company", params);
-
-        Map<String, Object> firstResult = result.iterator().next();
-
-        Assert.assertEquals(firstResult.size(), 1);
-
-        Company actual = (Company) firstResult.get("company");
-        Assert.assertEquals(actual.getName(), baeldung.getName());
-    }
-}

pom.xml

@@ -474,8 +474,6 @@
 
                 <module>apache-spark</module>
 
-                <module>image-processing</module>
-
                 <module>jenkins-modules</module>
                 <module>jhipster-modules</module>
             </modules>
@@ -637,8 +635,6 @@
 
                 <module>apache-spark</module>
 
-                <module>image-processing</module>
-
                 <module>jenkins-modules</module>
                 <module>jhipster-modules</module>
             </modules>
@@ -938,6 +934,7 @@
                 <module>web-modules</module>
                 <module>xml</module>
                 <module>xml-2</module>
+                <module>image-processing</module>
             </modules>
 
             <properties>
@@ -1204,6 +1201,7 @@
                 <module>web-modules</module>
                 <module>xml</module>
                 <module>xml-2</module>
+                <module>image-processing</module>
             </modules>
 
             <properties>

spring-boot-modules/spring-boot-redis/src/main/java/com/baelding/springbootredis/config/RedisConfiguration.java

@@ -2,7 +2,6 @@ package com.baelding.springbootredis.config;
 
 import com.baelding.springbootredis.model.Session;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.context.ApplicationListener;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.event.EventListener;

spring-boot-modules/spring-boot-redis/src/main/java/com/baelding/springbootredis/controller/SessionController.java

@@ -6,7 +6,6 @@ import com.baelding.springbootredis.service.cache.session.SessionCache;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
-import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.util.LinkedMultiValueMap;
 import org.springframework.util.MultiValueMap;

spring-boot-modules/spring-boot-redis/src/main/java/com/baelding/springbootredis/model/Session.java

@@ -1,19 +1,25 @@
 package com.baelding.springbootredis.model;
 
 import lombok.Builder;
-import lombok.Data;
 import lombok.EqualsAndHashCode;
+import lombok.Data;
+import lombok.NoArgsConstructor;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.redis.core.RedisHash;
 import org.springframework.data.redis.core.TimeToLive;
 
-@Data
 @Builder
 @EqualsAndHashCode
 @RedisHash(timeToLive = 60L)
+@Data
+@NoArgsConstructor
 public class Session {
     @Id
     private String id;
     @TimeToLive
     private Long expirationInSeconds;
+    public Session(String id, Long expirationInSeconds) {
+        this.id = id;
+        this.expirationInSeconds = expirationInSeconds;
+    }
 }

spring-boot-modules/spring-boot-redis/src/test/java/com/baelding/springbootredis/SpringBootRedisApplicationIntegrationTest.java

@@ -8,6 +8,7 @@ import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.http.HttpHeaders;
 import org.springframework.test.web.reactive.server.WebTestClient;
@@ -19,6 +20,7 @@ import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, classes = RedisTestConfiguration.class)
+@AutoConfigureMockMvc
 class SpringBootRedisApplicationIntegrationTest {
 
     private static final String V1_SESSIONS_ENDPOINT = "/v1/sessions";

spring-reactive-modules/spring-reactive-exceptions/pom.xml

@@ -20,10 +20,6 @@
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-webflux</artifactId>
         </dependency>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-web</artifactId>
-        </dependency>
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>

spring-web-modules/spring-mvc-java-3/README.md

@@ -1 +1,2 @@
 ### Relevant Articles:
+- [Java IllegalStateException: “getInputStream() has already been called for this request”](https://www.baeldung.com/java-servletrequest-illegalstateexception)

spring-web-modules/spring-thymeleaf/README.md

@@ -10,6 +10,7 @@ This module contains articles about Spring with Thymeleaf
 - [How to Work with Dates in Thymeleaf](https://www.baeldung.com/dates-in-thymeleaf)
 - [Working with Fragments in Thymeleaf](https://www.baeldung.com/spring-thymeleaf-fragments)
 - [JavaScript Function Call with Thymeleaf](https://www.baeldung.com/thymeleaf-js-function-call)
+- [Add a Checked Attribute to Input Conditionally in Thymeleaf](https://www.baeldung.com/thymeleaf-conditional-checked-attribute)
 - [[next -->]](/spring-thymeleaf-2)
 
 ### Build the Project

testing-modules/mockito-2/README.md

@@ -4,3 +4,4 @@ This module contains articles about Mockito
 
 ### Relevant Articles:
 - [Mocking a Singleton With Mockito](https://www.baeldung.com/java-mockito-singleton)
+- [Resolving Mockito Exception: Wanted But Not Invoked](https://www.baeldung.com/mockito-exception-wanted-but-not-invoked)

testing-modules/mockito-2/src/main/java/com/baeldung/nullmatcher/Helper.java

@@ -0,0 +1,9 @@
+package com.baeldung.nullmatcher;
+
+class Helper {
+
+    String concat(String a, String b) {
+        return a + b;
+    }
+
+}

testing-modules/mockito-2/src/main/java/com/baeldung/nullmatcher/Main.java

@@ -0,0 +1,11 @@
+package com.baeldung.nullmatcher;
+
+class Main {
+
+    Helper helper = new Helper();
+
+    String methodUnderTest() {
+        return helper.concat("Baeldung", null);
+    }
+
+}

testing-modules/mockito-2/src/test/java/com/baeldung/nullmatcher/MainUnitTest.java

@@ -0,0 +1,40 @@
+package com.baeldung.nullmatcher;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.isNull;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+
+class MainUnitTest {
+
+    @Mock
+    Helper helper;
+
+    @InjectMocks
+    Main main;
+
+    @BeforeEach
+    void openMocks() {
+        MockitoAnnotations.openMocks(this);
+    }
+
+    @Test
+    void whenMethodUnderTest_thenSecondParameterNull() {
+        main.methodUnderTest();
+        Mockito.verify(helper)
+          .concat("Baeldung", null);
+    }
+
+    @Test
+    void whenMethodUnderTest_thenSecondParameterNullWithMatchers() {
+        main.methodUnderTest();
+        Mockito.verify(helper)
+          .concat(any(), isNull());
+    }
+
+}

testing-modules/mockito-simple/src/test/java/com/baeldung/mockito/mockfinal/MockFinalsUnitTest.java

@@ -3,10 +3,8 @@ package com.baeldung.mockito.mockfinal;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
-import static org.mockito.Mockito.withSettings;
 
 import org.junit.jupiter.api.Test;
-import org.mockito.MockMakers;
 
 import com.baeldung.mockito.FinalList;
 import com.baeldung.mockito.MyList;
@@ -30,14 +28,4 @@ class MockFinalsUnitTest {
 
         assertThat(mock.size()).isNotEqualTo(1);
     }
-
-    @Test
-    public void whenMockFinalMethodMockWorks_withInlineMockMaker() {
-        MyList myList = new MyList();
-
-        MyList mock = mock(MyList.class, withSettings().mockMaker(MockMakers.INLINE));
-        when(mock.finalMethod()).thenReturn(1);
-
-        assertThat(mock.finalMethod()).isNotEqualTo(myList.finalMethod());
-    }
 }

testing-modules/mockito-simple/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker

@@ -1 +0,0 @@
-mock-maker-inline

testing-modules/testing-assertions/pom.xml

@@ -24,6 +24,22 @@
             <version>${commons-collections4.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.hamcrest</groupId>
+            <artifactId>hamcrest</artifactId>
+            <version>${hamcrest.version}</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
+    <properties>
+        <hamcrest.version>2.2</hamcrest.version>
+    </properties>
+
 </project>

testing-modules/testing-assertions/src/main/java/com/baeldung/assertequals/Address.java

@@ -0,0 +1,61 @@
+package com.baeldung.assertequals;
+
+public class Address {
+
+    private Long id;
+
+    private String city;
+
+    private String street;
+
+    private String country;
+
+    public Address(final Long id, final String city, final String street, final String country) {
+        this.id = id;
+        this.city = city;
+        this.street = street;
+        this.country = country;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(final Long id) {
+        this.id = id;
+    }
+
+    public String getCity() {
+        return city;
+    }
+
+    public void setCity(final String city) {
+        this.city = city;
+    }
+
+    public String getStreet() {
+        return street;
+    }
+
+    public void setStreet(final String street) {
+        this.street = street;
+    }
+
+    public String getCountry() {
+        return country;
+    }
+
+    public void setCountry(final String country) {
+        this.country = country;
+    }
+
+    @Override
+    public String toString() {
+        return "Address{" +
+                "id=" + id +
+                ", city='" + city + '\'' +
+                ", street='" + street + '\'' +
+                ", country='" + country + '\'' +
+                '}';
+    }
+}

testing-modules/testing-assertions/src/main/java/com/baeldung/assertequals/Person.java

@@ -0,0 +1,60 @@
+package com.baeldung.assertequals;
+
+public class Person {
+
+    private Long id;
+
+    private String firstName;
+
+    private String lastName;
+
+    private Address address;
+
+    public Person(final Long id, final String firstName, final String lastName) {
+        this.id = id;
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+
+    public Address getAddress() {
+        return address;
+    }
+
+    public void setAddress(final Address address) {
+        this.address = address;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(final Long id) {
+        this.id = id;
+    }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(final String firstName) {
+        this.firstName = firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public void setLastName(final String lastName) {
+        this.lastName = lastName;
+    }
+
+    @Override
+    public String toString() {
+        return "Person{" +
+                "id=" + id +
+                ", firstName='" + firstName + '\'' +
+                ", lastName='" + lastName + '\'' +
+                ", address=" + address +
+                '}';
+    }
+}

testing-modules/testing-assertions/src/test/java/com/baeldung/assertequals/EqualityUnitTest.java

@@ -0,0 +1,96 @@
+package com.baeldung.assertequals;
+
+import org.apache.commons.lang3.builder.EqualsBuilder;
+import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
+import org.apache.commons.lang3.builder.ToStringStyle;
+import org.hamcrest.MatcherAssert;
+import org.junit.jupiter.api.Test;
+import org.mockito.internal.matchers.apachecommons.ReflectionEquals;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.hamcrest.Matchers.samePropertyValuesAs;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class EqualityUnitTest {
+
+    @Test
+    void givenPersons_whenUseRecursiveComparison_thenOk() {
+        Person expected = new Person(1L, "Jane", "Doe");
+        Address address1 = new Address(1L, "New York", "Sesame Street", "United States");
+        expected.setAddress(address1);
+
+        Person actual = new Person(1L, "Jane", "Doe");
+        Address address2 = new Address(1L, "New York", "Sesame Street", "United States");
+        actual.setAddress(address2);
+
+        assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
+    }
+
+    @Test
+    void givenPersons_whenUseRecursiveComparisonIgnoringField_thenOk() {
+        Person expected = new Person(1L, "Jane", "Doe");
+        Person actual = new Person(2L, "Jane", "Doe");
+
+        assertThat(actual)
+                .usingRecursiveComparison()
+                .ignoringFields("id")
+                .isEqualTo(expected);
+    }
+
+    @Test
+    void givenPersons_whenCheckForSamePropertyValues_thenReturnOk() {
+        Person expected = new Person(1L, "Jane", "Doe");
+        Address address1 = new Address(1L, "New York", "Sesame Street", "United States");
+        expected.setAddress(address1);
+
+        Person actual = new Person(1L, "Jane", "Doe");
+        Address address2 = new Address(1L, "New York", "Sesame Street", "United States");
+        actual.setAddress(address2);
+
+        MatcherAssert.assertThat(actual, samePropertyValuesAs(expected, "address"));
+        MatcherAssert.assertThat(actual.getAddress(), samePropertyValuesAs(expected.getAddress()));
+    }
+
+    @Test
+    void givenPerson_whenReflectionToStringBuilder_thenReturnOk() {
+        Person expected = new Person(1L, "Jane", "Doe");
+        Address address1 = new Address(1L, "New York", "Sesame Street", "United States");
+        expected.setAddress(address1);
+
+        Person actual = new Person(1L, "Jane", "Doe");
+        Address address2 = new Address(1L, "New York", "Sesame Street", "United States");
+        actual.setAddress(address2);
+
+        assertThat(ReflectionToStringBuilder.toString(actual, ToStringStyle.SHORT_PREFIX_STYLE))
+                .isEqualTo(ReflectionToStringBuilder.toString(expected, ToStringStyle.SHORT_PREFIX_STYLE));
+    }
+
+    @Test
+    void givenPersons_whenEqualsBuilder_thenReturnTrue() {
+        Person expected = new Person(1L, "Jane", "Doe");
+        Address address1 = new Address(1L, "New York", "Sesame Street", "United States");
+        expected.setAddress(address1);
+
+        Person actual = new Person(1L, "Jane", "Doe");
+        Address address2 = new Address(1L, "New York", "Sesame Street", "United States");
+        actual.setAddress(address2);
+
+        assertTrue(EqualsBuilder.reflectionEquals(expected, actual, "address"));
+        assertTrue(EqualsBuilder.reflectionEquals(expected.getAddress(), actual.getAddress()));
+    }
+
+    @Test
+    void givenPersons_whenReflectionEquals_thenReturnOk() {
+        Person expected = new Person(1L, "Jane", "Doe");
+        Address address1 = new Address(1L, "New York", "Sesame Street", "United States");
+        expected.setAddress(address1);
+
+        Person actual = new Person(1L, "Jane", "Doe");
+        Address address2 = new Address(1L, "New York", "Sesame Street", "United States");
+        actual.setAddress(address2);
+
+        assertTrue(new ReflectionEquals(expected, "address").matches(actual));
+        assertTrue(new ReflectionEquals(expected.getAddress()).matches(actual.getAddress()));
+    }
+
+}