Merge remote-tracking branch 'Baeldung/master' into active_mq

# Conflicts:
#	.gitignore
#	LICENSE
#	README.md
#	core-java-modules/README.md
#	core-java-modules/core-java-11/README.md
#	core-java-modules/core-java-11/pom.xml
#	core-java-modules/core-java-8/README.md
#	core-java-modules/core-java-8/pom.xml
#	core-java-modules/core-java-8/src/main/resources/logback.xml
#	core-java-modules/core-java-annotations/README.md
#	core-java-modules/core-java-annotations/pom.xml
#	core-java-modules/core-java-collections-2/README.md
#	core-java-modules/core-java-collections-2/pom.xml
#	core-java-modules/core-java-collections-3/README.md
#	core-java-modules/core-java-collections-3/pom.xml
#	core-java-modules/core-java-collections-conversions-2/README.md
#	core-java-modules/core-java-collections-conversions-2/pom.xml
#	core-java-modules/core-java-collections-conversions/README.md
#	core-java-modules/core-java-collections-conversions/pom.xml
#	core-java-modules/core-java-collections-list/README.md
#	core-java-modules/core-java-collections-list/pom.xml
#	core-java-modules/core-java-collections/pom.xml
#	core-java-modules/core-java-datetime-conversion/README.md
#	core-java-modules/core-java-datetime-conversion/pom.xml
#	core-java-modules/core-java-datetime-conversion/src/test/java/com/baeldung/datetime/ConvertInstantToTimestampUnitTest.java
#	core-java-modules/core-java-io-2/pom.xml
#	core-java-modules/core-java-io/README.md
#	core-java-modules/core-java-io/pom.xml
#	core-java-modules/core-java-io/src/test/resources/fileTest.txt
#	core-java-modules/core-java-io/src/test/resources/sampleTextFile.txt
#	core-java-modules/core-java-lambdas/README.md
#	core-java-modules/core-java-lambdas/pom.xml
#	core-java-modules/core-java-serialization/pom.xml
#	core-java-modules/core-java-streams/README.md
#	core-java-modules/core-java-streams/pom.xml
#	core-java-modules/core-java-strings/README.md
#	core-java-modules/core-java-strings/pom.xml
#	core-java-modules/core-java-strings/src/test/resources/stringtoolong.txt
#	core-java-modules/core-java-uuid/README.md
#	core-java-modules/core-java-uuid/pom.xml
#	core-java-modules/pom.xml
#	image-processing/README.md
#	image-processing/pom.xml
#	image-processing/src/main/java/com/baeldung/imageprocessing/addingtext/AddText.java
#	image-processing/src/main/java/com/baeldung/imageprocessing/opencv/CameraStream.java
#	jackson-modules/jackson-annotations/README.md
#	jackson-modules/jackson-annotations/pom.xml
#	jackson-modules/jackson-conversions-2/README.md
#	jackson-modules/jackson-conversions-2/pom.xml
#	jackson-modules/jackson-conversions/README.md
#	jackson-modules/jackson-conversions/pom.xml
#	jackson-modules/jackson-custom-conversions/README.md
#	jackson-modules/jackson-custom-conversions/pom.xml
#	jackson-modules/jackson-custom-conversions/src/test/java/com/baeldung/defaultserializercustomserializer/CallingDefaultSerializerUnitTest.java
#	jackson-modules/jackson-custom-conversions/src/test/java/com/baeldung/deserialization/CustomDeserializationUnitTest.java
#	jackson-modules/jackson-exceptions/README.md
#	jackson-modules/jackson-exceptions/pom.xml
#	jackson-modules/jackson-exceptions/src/test/java/com/baeldung/exceptions/JacksonExceptionsUnitTest.java
#	jackson-modules/jackson-exceptions/src/test/java/com/baeldung/mappingexception/JacksonMappingExceptionUnitTest.java
#	jackson-modules/pom.xml
#	parent-boot-1/pom.xml
#	parent-boot-2/pom.xml
#	parent-boot-3/pom.xml
#	patterns-modules/design-patterns-architectural/pom.xml
#	patterns-modules/design-patterns-architectural/src/main/java/com/baeldung/repositoryvsdaopattern/UserDaoImpl.java
#	patterns-modules/design-patterns-behavioral-2/README.md
#	patterns-modules/design-patterns-behavioral-2/pom.xml
#	patterns-modules/design-patterns-creational-2/README.md
#	patterns-modules/design-patterns-creational-2/pom.xml
#	patterns-modules/design-patterns-singleton/README.md
#	patterns-modules/design-patterns-structural/src/main/resources/log4jstructuraldp.properties
#	patterns-modules/enterprise-patterns/pom.xml
#	patterns-modules/intercepting-filter/pom.xml
#	patterns-modules/pom.xml
#	persistence-modules/activejdbc/pom.xml
#	persistence-modules/hibernate5/README.md
#	persistence-modules/hibernate5/pom.xml
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/interceptors/CustomInterceptor.java
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/interceptors/entity/User.java
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/namingstrategy/CustomPhysicalNamingStrategy.java
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/persistjson/Customer.java
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/persistjson/HashMapConverter.java
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/pojo/OrderEntryIdClass.java
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/pojo/OrderEntryPK.java
#	persistence-modules/hibernate5/src/test/java/com/baeldung/hibernate/IdentifiersIntegrationTest.java
#	persistence-modules/hibernate5/src/test/java/com/baeldung/hibernate/bootstrap/BootstrapAPIIntegrationTest.java
#	persistence-modules/hibernate5/src/test/java/com/baeldung/hibernate/proxy/HibernateProxyUnitTest.java
#	persistence-modules/hibernate5/src/test/resources/hibernate-interceptors.properties
#	persistence-modules/hibernate5/src/test/resources/hibernate-lifecycle.properties
#	persistence-modules/hibernate5/src/test/resources/hibernate-namingstrategy.properties
#	persistence-modules/hibernate5/src/test/resources/hibernate-persistjson.properties
#	persistence-modules/hibernate5/src/test/resources/hibernate.properties
#	persistence-modules/pom.xml
#	persistence-modules/spring-data-jpa-crud/pom.xml
#	persistence-modules/spring-data-jpa-crud/src/main/java/com/baeldung/repository/FruitRepository.java
#	persistence-modules/spring-data-jpa-repo-2/README.md
#	persistence-modules/spring-data-jpa-repo-2/pom.xml
#	persistence-modules/spring-data-jpa-repo-2/src/main/java/com/baeldung/spring/data/persistence/customrepository/model/User.java
#	persistence-modules/spring-data-jpa-repo-2/src/main/java/com/baeldung/spring/data/persistence/customrepository/repository/CustomUserRepositoryImpl.java
#	persistence-modules/spring-data-jpa-repo-2/src/main/java/com/baeldung/spring/data/persistence/saveperformance/Book.java
#	persistence-modules/spring-data-jpa-repo-2/src/main/resources/application.properties
#	persistence-modules/spring-data-mongodb-reactive/pom.xml
#	persistence-modules/spring-data-redis/README.md
#	persistence-modules/spring-data-redis/pom.xml
#	persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/reactive/redis/config/RedisConfig.java
#	persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/config/RedisConfig.java
#	persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/model/Student.java
#	persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/queue/RedisMessageSubscriber.java
#	persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/reactive/redis/template/RedisKeyCommandsManualTest.java
#	persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/reactive/redis/template/RedisTemplateListOpsManualTest.java
#	persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/reactive/redis/template/RedisTemplateValueOpsManualTest.java
#	persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/redis/repo/StudentRepositoryManualTest.java
#	pom.xml
#	testing-modules/assertion-libraries/README.md
#	testing-modules/assertion-libraries/pom.xml
#	testing-modules/junit-5-basics/README.md
#	testing-modules/junit-5-basics/pom.xml
#	testing-modules/mockito-2/src/main/java/com/baeldung/nullmatcher/Helper.java
#	testing-modules/mockito-2/src/main/java/com/baeldung/nullmatcher/Main.java
#	testing-modules/mockito-2/src/main/java/com/baeldung/wantedbutnotinvocked/Helper.java
#	testing-modules/mockito-2/src/main/java/com/baeldung/wantedbutnotinvocked/Main.java
#	testing-modules/mockito-2/src/test/java/com/baeldung/nullmatcher/MainUnitTest.java
#	testing-modules/mockito-2/src/test/java/com/baeldung/wantedbutnotinvocked/MainUnitTest.java
#	testing-modules/pom.xml
#	testing-modules/spring-mockito/pom.xml
#	web-modules/dropwizard/pom.xml
#	web-modules/jakarta-ee/README.md
#	web-modules/jakarta-ee/pom.xml
#	web-modules/jakarta-ee/src/test/java/com/baeldung/eclipse/krazo/UserControllerUnitTest.java
#	web-modules/java-lite/pom.xml
#	web-modules/javax-servlets-2/README.md
#	web-modules/javax-servlets-2/pom.xml
#	web-modules/javax-servlets/pom.xml
#	web-modules/jee-7/pom.xml
#	web-modules/jooby/pom.xml
#	web-modules/ninja/pom.xml
#	web-modules/pom.xml
#	web-modules/ratpack/pom.xml
#	web-modules/resteasy/pom.xml
#	web-modules/restx/pom.xml
#	web-modules/spark-java/pom.xml
#	web-modules/vraptor/pom.xml
#	xml/README.md
#	xml/pom.xml
#	xml/src/main/resources/customer-binding.xml
#	xml/src/main/resources/sax/baeldung.xml
#	xml/src/test/resources/example_default_parser.xml
#	xml/src/test/resources/example_dom4j.xml
#	xml/src/test/resources/example_jaxb.xml
#	xml/src/test/resources/example_jaxen.xml
#	xml/src/test/resources/example_jdom.xml
#	xml/src/test/resources/example_stax.xml
#	xml/src/test/resources/sax/baeldung.xml
#	xml/src/test/resources/xml/websites.xml
#	xml/src/test/resources/xml/xee_attribute.xml

testing-modules/junit-5-basics/src/main/java/com/baeldung/failure_vs_error/SimpleCalculator.java

@@ -0,0 +1,15 @@
+package com.baeldung.failure_vs_error;
+
+/**
+ * @author paullatzelsperger
+ * @since 2019-07-17
+ */
+public class SimpleCalculator {
+
+    public static double divideNumbers(double dividend, double divisor) {
+        if (divisor == 0) {
+            throw new ArithmeticException("Division by zero!");
+        }
+        return dividend / divisor;
+    }
+}

testing-modules/junit-5-basics/src/main/java/com/baeldung/junit/tags/example/Employee.java

@@ -0,0 +1,44 @@
+package com.baeldung.junit.tags.example;
+
+public class Employee {
+    private int id;
+
+    private String firstName;
+
+    private String lastName;
+
+    private String address;
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(final int 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;
+    }
+
+    public String getAddress() {
+        return address;
+    }
+
+    public void setAddress(final String address) {
+        this.address = address;
+    }
+
+}

testing-modules/junit-5-basics/src/main/java/com/baeldung/junit/tags/example/EmployeeDAO.java

@@ -0,0 +1,58 @@
+package com.baeldung.junit.tags.example;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
+import org.springframework.jdbc.core.simple.SimpleJdbcInsert;
+import org.springframework.stereotype.Repository;
+
+import javax.sql.DataSource;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Repository
+public class EmployeeDAO {
+
+    private JdbcTemplate jdbcTemplate;
+
+    private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
+
+    private SimpleJdbcInsert simpleJdbcInsert;
+
+    @Autowired
+    public void setDataSource(final DataSource dataSource) {
+        jdbcTemplate = new JdbcTemplate(dataSource);
+
+        namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(dataSource);
+        simpleJdbcInsert = new SimpleJdbcInsert(dataSource).withTableName("EMPLOYEE");
+
+    }
+
+    public int getCountOfEmployees() {
+        return jdbcTemplate.queryForObject("SELECT COUNT(*) FROM EMPLOYEE", Integer.class);
+    }
+
+    public List<Employee> getAllEmployees() {
+        return jdbcTemplate.query("SELECT * FROM EMPLOYEE", new EmployeeRowMapper());
+    }
+
+    public int addEmplyee(final int id) {
+        return jdbcTemplate.update("INSERT INTO EMPLOYEE VALUES (?, ?, ?, ?)", id, "Bill", "Gates", "USA");
+    }
+
+    public int addEmplyeeUsingSimpelJdbcInsert(final Employee emp) {
+        final Map<String, Object> parameters = new HashMap<String, Object>();
+        parameters.put("ID", emp.getId());
+        parameters.put("FIRST_NAME", emp.getFirstName());
+        parameters.put("LAST_NAME", emp.getLastName());
+        parameters.put("ADDRESS", emp.getAddress());
+
+        return simpleJdbcInsert.execute(parameters);
+    }
+
+    // for testing
+    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
+        this.jdbcTemplate = jdbcTemplate;
+    }
+}

testing-modules/junit-5-basics/src/main/java/com/baeldung/junit/tags/example/EmployeeRowMapper.java

@@ -0,0 +1,21 @@
+package com.baeldung.junit.tags.example;
+
+import org.springframework.jdbc.core.RowMapper;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class EmployeeRowMapper implements RowMapper<Employee> {
+
+    @Override
+    public Employee mapRow(final ResultSet rs, final int rowNum) throws SQLException {
+        final Employee employee = new Employee();
+
+        employee.setId(rs.getInt("ID"));
+        employee.setFirstName(rs.getString("FIRST_NAME"));
+        employee.setLastName(rs.getString("LAST_NAME"));
+        employee.setAddress(rs.getString("ADDRESS"));
+
+        return employee;
+    }
+}

testing-modules/junit-5-basics/src/main/java/com/baeldung/junit/tags/example/SpringJdbcConfig.java

@@ -0,0 +1,19 @@
+package com.baeldung.junit.tags.example;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
+import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
+
+import javax.sql.DataSource;
+
+@Configuration
+@ComponentScan("com.baeldung.junit.tags.example")
+public class SpringJdbcConfig {
+
+    @Bean
+    public DataSource dataSource() {
+        return new EmbeddedDatabaseBuilder().setType(EmbeddedDatabaseType.H2).addScript("classpath:jdbc/schema.sql").addScript("classpath:jdbc/test-data.sql").build();
+    }
+}

testing-modules/junit-5-basics/src/main/java/com/baeldung/junit5/Greetings.java

@@ -0,0 +1,9 @@
+package com.baeldung.junit5;
+
+public class Greetings {
+
+    public static String sayHello() {
+        return "Hello";
+    }
+
+}

testing-modules/junit-5-basics/src/main/java/com/baeldung/junit5/bean/NumbersBean.java

@@ -0,0 +1,22 @@
+package com.baeldung.junit5.bean;
+
+/**
+ * Bean that contains utility methods to work with numbers.
+ * 
+ * @author Donato Rimenti
+ *
+ */
+public class NumbersBean {
+
+    /**
+     * Returns true if a number is even, false otherwise.
+     * 
+     * @param number
+     *            the number to check
+     * @return true if the argument is even, false otherwise
+     */
+    public boolean isNumberEven(int number) {
+        return number % 2 == 0;
+    }
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/ExceptionUnitTest.java

@@ -0,0 +1,39 @@
+package com.baeldung;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.function.Executable;
+
+import java.util.ConcurrentModificationException;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class ExceptionUnitTest {
+
+    @Test
+    void shouldThrowException() {
+        Throwable exception = assertThrows(UnsupportedOperationException.class, () -> {
+            throw new UnsupportedOperationException("Not supported");
+        });
+
+        assertEquals("Not supported", exception.getMessage());
+    }
+
+    @Test
+    void assertThrowsException() {
+        String str = null;
+        assertThrows(IllegalArgumentException.class, () -> Integer.valueOf(str));
+    }
+
+    @Test
+    void whenModifyMapDuringIteration_thenThrowException() {
+        Map<Integer, String> hashmap = new HashMap<>();
+        hashmap.put(1, "One");
+        hashmap.put(2, "Two");
+
+        Executable executable = () -> hashmap.forEach((key, value) -> hashmap.remove(1));
+        assertThrows(ConcurrentModificationException.class, executable);
+    }
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/FirstUnitTest.java

@@ -0,0 +1,37 @@
+package com.baeldung;
+
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class FirstUnitTest {
+
+    @Test
+    void lambdaExpressions() {
+        List<Integer> numbers = Arrays.asList(1, 2, 3);
+        assertTrue(numbers.stream()
+                .mapToInt(Integer::intValue)
+                .sum() > 5, "Sum should be greater than 5");
+    }
+
+    @Disabled("test to show MultipleFailuresError")
+    @Test
+    void groupAssertions() {
+        int[] numbers = {0, 1, 2, 3, 4};
+        assertAll("numbers",
+                () -> assertEquals(numbers[0], 1),
+                () -> assertEquals(numbers[3], 3),
+                () -> assertEquals(numbers[4], 1)
+        );
+    }
+
+    @Test
+    @Disabled("Disabled test example")
+    void disabledTest() {
+        fail();
+    }
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/GreetingsUnitTest.java

@@ -0,0 +1,16 @@
+package com.baeldung;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+import com.baeldung.junit5.Greetings;
+
+public class GreetingsUnitTest {
+
+    @Test
+    void whenCallingSayHello_thenReturnHello() {
+        assertTrue("Hello".equals(Greetings.sayHello()));
+    }
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/JUnit5NewFeaturesUnitTest.java

@@ -0,0 +1,42 @@
+package com.baeldung;
+
+import org.junit.jupiter.api.*;
+
+import java.util.logging.Logger;
+
+class JUnit5NewFeaturesUnitTest {
+
+    private static final Logger log = Logger.getLogger(JUnit5NewFeaturesUnitTest.class.getName());
+
+    @BeforeAll
+    static void setup() {
+        log.info("@BeforeAll - executes once before all test methods in this class");
+    }
+
+    @BeforeEach
+    void init() {
+        log.info("@BeforeEach - executes before each test method in this class");
+    }
+
+    @DisplayName("Single test successful")
+    @Test
+    void testSingleSuccessTest() {
+        log.info("Success");
+    }
+
+    @Test
+    @Disabled("Not implemented yet.")
+    void testShowSomething() {
+    }
+
+    @AfterEach
+    void tearDown() {
+        log.info("@AfterEach - executed after each test method.");
+    }
+
+    @AfterAll
+    static void done() {
+        log.info("@AfterAll - executed after all test methods.");
+    }
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/LiveTest.java

@@ -0,0 +1,39 @@
+package com.baeldung;
+
+import org.junit.jupiter.api.DynamicTest;
+import org.junit.jupiter.api.TestFactory;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class LiveTest {
+
+    private List<String> in = new ArrayList<>(Arrays.asList("Hello", "Yes", "No"));
+    private List<String> out = new ArrayList<>(Arrays.asList("Cześć", "Tak", "Nie"));
+
+    @TestFactory
+    Stream<DynamicTest> translateDynamicTestsFromStream() {
+
+        return in.stream()
+                .map(word -> DynamicTest.dynamicTest("Test translate " + word, () -> {
+                    int id = in.indexOf(word);
+                    assertEquals(out.get(id), translate(word));
+                }));
+    }
+
+    private String translate(String word) {
+        if ("Hello".equalsIgnoreCase(word)) {
+            return "Cześć";
+        } else if ("Yes".equalsIgnoreCase(word)) {
+            return "Tak";
+        } else if ("No".equalsIgnoreCase(word)) {
+            return "Nie";
+        }
+        return "Error";
+    }
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/assertexception/ExceptionAssertionUnitTest.java

@@ -0,0 +1,30 @@
+package com.baeldung.assertexception;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ExceptionAssertionUnitTest {
+
+    @Test
+    void whenExceptionThrown_thenAssertionSucceeds() {
+        Exception exception = assertThrows(NumberFormatException.class, () -> Integer.parseInt("1a"));
+
+        String expectedMessage = "For input string";
+        String actualMessage = exception.getMessage();
+
+        assertTrue(actualMessage.contains(expectedMessage));
+    }
+
+    @Test
+    void whenDerivedExceptionThrown_thenAssertionSucceeds() {
+        Exception exception = assertThrows(RuntimeException.class, () -> Integer.parseInt("1a"));
+
+        String expectedMessage = "For input string";
+        String actualMessage = exception.getMessage();
+
+        assertTrue(actualMessage.contains(expectedMessage));
+    }
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/assertexception/migration/junit4/ExceptionAssertionUnitTest.java

@@ -0,0 +1,24 @@
+package com.baeldung.assertexception.migration.junit4;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+public class ExceptionAssertionUnitTest {
+
+    @Rule
+    public ExpectedException exceptionRule = ExpectedException.none();
+
+    @Test(expected = NullPointerException.class)
+    public void whenExceptionThrown_thenExpectationSatisfied() {
+        String test = null;
+        test.length();
+    }
+
+    @Test
+    public void whenExceptionThrown_thenRuleIsApplied() {
+        exceptionRule.expect(NumberFormatException.class);
+        exceptionRule.expectMessage("For input string");
+        Integer.parseInt("1a");
+    }
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/categories/EmployeeDAOCategoryIntegrationTest.java

@@ -0,0 +1,66 @@
+package com.baeldung.categories;
+
+import com.baeldung.junit.tags.example.Employee;
+import com.baeldung.junit.tags.example.EmployeeDAO;
+import com.baeldung.junit.tags.example.SpringJdbcConfig;
+import org.hamcrest.CoreMatchers;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { SpringJdbcConfig.class }, loader = AnnotationConfigContextLoader.class)
+public class EmployeeDAOCategoryIntegrationTest {
+
+    @Autowired
+    private EmployeeDAO employeeDao;
+
+    @Mock
+    private JdbcTemplate jdbcTemplate;
+    private EmployeeDAO employeeDAO;
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        employeeDAO = new EmployeeDAO();
+        employeeDAO.setJdbcTemplate(jdbcTemplate);
+    }
+
+    @Test
+    @Category(IntegrationTest.class)
+    public void testAddEmployeeUsingSimpelJdbcInsert() {
+        final Employee emp = new Employee();
+        emp.setId(12);
+        emp.setFirstName("testFirstName");
+        emp.setLastName("testLastName");
+        emp.setAddress("testAddress");
+
+        Assert.assertEquals(employeeDao.addEmplyeeUsingSimpelJdbcInsert(emp), 1);
+    }
+
+    @Test
+    @Category(UnitTest.class)
+    public void givenNumberOfEmployeeWhenCountEmployeeThenCountMatch() {
+
+        // given
+        Mockito.when(jdbcTemplate.queryForObject(Mockito.any(String.class), Mockito.eq(Integer.class)))
+                .thenReturn(1);
+
+        // when
+        int countOfEmployees = employeeDAO.getCountOfEmployees();
+
+        // then
+        Assert.assertThat(countOfEmployees, CoreMatchers.is(1));
+    }
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/categories/EmployeeDAOUnitTestSuite.java

@@ -0,0 +1,12 @@
+package com.baeldung.categories;
+
+import org.junit.experimental.categories.Categories;
+import org.junit.experimental.categories.Categories.IncludeCategory;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Categories.class)
+@IncludeCategory(UnitTest.class)
+@SuiteClasses(EmployeeDAOCategoryIntegrationTest.class)
+public class EmployeeDAOUnitTestSuite {
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/categories/IntegrationTest.java

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

testing-modules/junit-5-basics/src/test/java/com/baeldung/categories/UnitTest.java

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

testing-modules/junit-5-basics/src/test/java/com/baeldung/example/EmployeeDAOIntegrationTest.java

@@ -0,0 +1,45 @@
+package com.baeldung.example;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.annotation.DirtiesContext.ClassMode;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import com.baeldung.junit.tags.example.Employee;
+import com.baeldung.junit.tags.example.EmployeeDAO;
+import com.baeldung.junit.tags.example.SpringJdbcConfig;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { SpringJdbcConfig.class }, loader = AnnotationConfigContextLoader.class)
+@DirtiesContext(classMode = ClassMode.BEFORE_EACH_TEST_METHOD)
+public class EmployeeDAOIntegrationTest {
+
+    @Autowired
+    private EmployeeDAO employeeDao;
+
+    @Test
+    public void testQueryMethod() {
+        Assert.assertEquals(employeeDao.getAllEmployees().size(), 4);
+    }
+
+    @Test
+    public void testUpdateMethod() {
+        Assert.assertEquals(employeeDao.addEmplyee(5), 1);
+    }
+
+    @Test
+    public void testAddEmployeeUsingSimpelJdbcInsert() {
+        final Employee emp = new Employee();
+        emp.setId(11);
+        emp.setFirstName("testFirstName");
+        emp.setLastName("testLastName");
+        emp.setAddress("testAddress");
+
+        Assert.assertEquals(employeeDao.addEmplyeeUsingSimpelJdbcInsert(emp), 1);
+    }
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/example/EmployeeUnitTest.java

@@ -0,0 +1,40 @@
+package com.baeldung.example;
+
+import com.baeldung.junit.tags.example.EmployeeDAO;
+import org.hamcrest.CoreMatchers;
+import org.junit.Assert;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+public class EmployeeUnitTest {
+
+    @Mock
+    private JdbcTemplate jdbcTemplate;
+
+    private EmployeeDAO employeeDAO;
+
+    @BeforeEach
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        employeeDAO = new EmployeeDAO();
+        employeeDAO.setJdbcTemplate(jdbcTemplate);
+    }
+
+    @Test
+    public void givenNumberOfEmployeeWhenCountEmployeeThenCountMatch() {
+
+        // given
+        Mockito.when(jdbcTemplate.queryForObject(Mockito.any(String.class), Mockito.eq(Integer.class)))
+            .thenReturn(1);
+
+        // when
+        int countOfEmployees = employeeDAO.getCountOfEmployees();
+
+        // then
+        Assert.assertThat(countOfEmployees, CoreMatchers.is(1));
+    }
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/extensions/tempdir/SharedTemporaryDirectoryUnitTest.java

@@ -0,0 +1,49 @@
+package com.baeldung.extensions.tempdir;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertLinesMatch;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.io.TempDir;
+
+import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
+
+@TestMethodOrder(OrderAnnotation.class)
+class SharedTemporaryDirectoryUnitTest {
+
+    @TempDir
+    static Path sharedTempDir;
+    
+    @Test
+    @Order(1)
+    void givenFieldWithSharedTempDirectoryPath_whenWriteToFile_thenContentIsCorrect() throws IOException {
+        Path numbers = sharedTempDir.resolve("numbers.txt");
+
+        List<String> lines = Arrays.asList("1", "2", "3");
+        Files.write(numbers, lines);
+
+        assertAll(
+            () -> assertTrue("File should exist", Files.exists(numbers)),
+            () -> assertLinesMatch(lines, Files.readAllLines(numbers)));
+        
+        Files.createTempDirectory("bpb");
+    }
+
+    @Test
+    @Order(2)
+    void givenAlreadyWrittenToSharedFile_whenCheckContents_thenContentIsCorrect() throws IOException {
+        Path numbers = sharedTempDir.resolve("numbers.txt");
+
+        assertLinesMatch(Arrays.asList("1", "2", "3"), Files.readAllLines(numbers));
+    }
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/extensions/tempdir/TemporaryDirectoryUnitTest.java

@@ -0,0 +1,48 @@
+package com.baeldung.extensions.tempdir;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertLinesMatch;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class TemporaryDirectoryUnitTest {
+
+    @Test
+    void givenTestMethodWithTempDirectoryPath_whenWriteToFile_thenContentIsCorrect(@TempDir Path tempDir) throws IOException {
+        Path numbers = tempDir.resolve("numbers.txt");
+
+        List<String> lines = Arrays.asList("1", "2", "3");
+        Files.write(numbers, lines);
+
+        assertAll(
+            () -> assertTrue("File should exist", Files.exists(numbers)),
+            () -> assertLinesMatch(lines, Files.readAllLines(numbers)));
+    }
+
+    @TempDir
+    File anotherTempDir;
+
+    @Test
+    void givenFieldWithTempDirectoryFile_whenWriteToFile_thenContentIsCorrect() throws IOException {
+        assertTrue("Should be a directory ", this.anotherTempDir.isDirectory());
+
+        File letters = new File(anotherTempDir, "letters.txt");
+        List<String> lines = Arrays.asList("x", "y", "z");
+
+        Files.write(letters.toPath(), lines);
+        
+        assertAll(
+            () -> assertTrue("File should exist", Files.exists(letters.toPath())),
+            () -> assertLinesMatch(lines, Files.readAllLines(letters.toPath())));
+    }
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/extensions/tempdir/TemporaryDirectoryWithCleanupUnitTest.java

@@ -0,0 +1,36 @@
+package com.baeldung.extensions.tempdir;
+
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.nio.file.Path;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.io.CleanupMode.NEVER;
+
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class TemporaryDirectoryWithCleanupUnitTest {
+
+    private Path theTempDirToBeChecked = null;
+
+    @Test
+    @Order(1)
+    void whenTestMethodWithTempDirNeverCleanup_thenSetInstanceVariable(@TempDir(cleanup = NEVER) Path tempDir) {
+        theTempDirToBeChecked = tempDir;
+        System.out.println(tempDir.toFile().getAbsolutePath());
+    }
+
+    @Test
+    @Order(2)
+    void whenTestMethodWithTempDirNeverCleanup_thenTempDirShouldNotBeRemoved() {
+        assertNotNull(theTempDirToBeChecked);
+        assertTrue(theTempDirToBeChecked.toFile().isDirectory());
+    }
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/failure_vs_error/SimpleCalculatorUnitTest.java

@@ -0,0 +1,39 @@
+package com.baeldung.failure_vs_error;
+
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * @author paullatzelsperger
+ * @since 2019-07-17
+ */
+class SimpleCalculatorUnitTest {
+
+    @Test
+    void whenDivideByValidNumber_thenAssertCorrectResult() {
+        double result = SimpleCalculator.divideNumbers(6, 3);
+        assertEquals(2, result);
+    }
+
+    @Test
+    @Disabled("test is expected to fail, disabled so that CI build still goes through")
+    void whenDivideNumbers_thenExpectWrongResult() {
+        double result = SimpleCalculator.divideNumbers(6, 3);
+        assertEquals(15, result);
+    }
+
+    @Test
+    @Disabled("test is expected to raise an error, disabled so that CI build still goes through")
+    void whenDivideByZero_thenThrowsException() {
+        SimpleCalculator.divideNumbers(10, 0);
+    }
+
+    @Test
+    void whenDivideByZero_thenAssertException(){
+        assertThrows(ArithmeticException.class, () -> SimpleCalculator.divideNumbers(10, 0));
+    }
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/junit5/bean/test/NumbersBeanUnitTest.java

@@ -0,0 +1,43 @@
+package com.baeldung.junit5.bean.test;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import com.baeldung.junit5.bean.NumbersBean;
+
+/**
+ * Test class for {@link NumbersBean}.
+ * 
+ * @author Donato Rimenti
+ *
+ */
+public class NumbersBeanUnitTest {
+
+	/**
+	 * The bean to test.
+	 */
+	private NumbersBean bean = new NumbersBean();
+
+	/**
+	 * Tests that when an even number is passed to
+	 * {@link NumbersBean#isNumberEven(int)}, true is returned.
+	 */
+	@Test
+	void givenEvenNumber_whenCheckingIsNumberEven_thenTrue() {
+		boolean result = bean.isNumberEven(8);
+
+		Assertions.assertTrue(result);
+	}
+
+	/**
+	 * Tests that when an odd number is passed to
+	 * {@link NumbersBean#isNumberEven(int)}, false is returned.
+	 */
+	@Test
+	void givenOddNumber_whenCheckingIsNumberEven_thenFalse() {
+		boolean result = bean.isNumberEven(3);
+
+		Assertions.assertFalse(result);
+	}
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/junit5/spring/GreetingsSpringUnitTest.java

@@ -0,0 +1,21 @@
+package com.baeldung.junit5.spring;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+
+import com.baeldung.junit5.Greetings;
+
+@ExtendWith(SpringExtension.class)
+@ContextConfiguration(classes = { SpringTestConfiguration.class })
+public class GreetingsSpringUnitTest {
+
+    @Test
+    void whenCallingSayHello_thenReturnHello() {
+        assertTrue("Hello".equals(Greetings.sayHello()));
+    }
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/junit5/spring/SpringTestConfiguration.java

@@ -0,0 +1,8 @@
+package com.baeldung.junit5.spring;
+
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class SpringTestConfiguration {
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/migration/junit4/AnnotationTestExampleUnitTest.java

@@ -0,0 +1,23 @@
+package com.baeldung.migration.junit4;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import com.baeldung.migration.junit4.categories.Annotations;
+import com.baeldung.migration.junit4.categories.JUnit4UnitTest;
+
+@Category(value = { Annotations.class, JUnit4UnitTest.class })
+public class AnnotationTestExampleUnitTest {
+    @Test(expected = Exception.class)
+    public void shouldRaiseAnException() throws Exception {
+        throw new Exception("This is my expected exception");
+    }
+
+    @Test(timeout = 1)
+    @Ignore
+    public void shouldFailBecauseTimeout() throws InterruptedException {
+        Thread.sleep(10);
+    }
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/migration/junit4/AssertionsExampleUnitTest.java

@@ -0,0 +1,28 @@
+package com.baeldung.migration.junit4;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class AssertionsExampleUnitTest {
+    @Test
+    @Ignore
+    public void shouldFailBecauseTheNumbersAreNotEqualld() {
+        assertEquals("Numbers are not equal!", 2, 3);
+    }
+
+    @Test
+    public void shouldAssertAllTheGroup() {
+        List<Integer> list = Arrays.asList(1, 2, 3);
+        assertEquals("List is not incremental", list.get(0)
+            .intValue(), 1);
+        assertEquals("List is not incremental", list.get(1)
+            .intValue(), 2);
+        assertEquals("List is not incremental", list.get(2)
+            .intValue(), 3);
+    }
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/migration/junit4/BeforeAndAfterAnnotationsUnitTest.java

@@ -0,0 +1,51 @@
+package com.baeldung.migration.junit4;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@RunWith(JUnit4.class)
+public class BeforeAndAfterAnnotationsUnitTest {
+
+    private static final Logger LOG = LoggerFactory.getLogger(BeforeAndAfterAnnotationsUnitTest.class);
+
+    private List<String> list;
+
+    @Before
+    public void init() {
+        LOG.debug("startup");
+        list = new ArrayList<>(Arrays.asList("test1", "test2"));
+    }
+
+    @After
+    public void teardown() {
+        LOG.debug("teardown");
+        list.clear();
+    }
+
+    @Test
+    public void whenCheckingListSize_thenSizeEqualsToInit() {
+        LOG.debug("executing test");
+        assertEquals(2, list.size());
+
+        list.add("another test");
+    }
+
+    @Test
+    public void whenCheckingListSizeAgain_thenSizeEqualsToInit() {
+        LOG.debug("executing another test");
+        assertEquals(2, list.size());
+
+        list.add("yet another test");
+    }
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/migration/junit4/BeforeClassAndAfterClassAnnotationsUnitTest.java

@@ -0,0 +1,35 @@
+package com.baeldung.migration.junit4;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@RunWith(JUnit4.class)
+public class BeforeClassAndAfterClassAnnotationsUnitTest {
+
+    private static final Logger LOG = LoggerFactory.getLogger(BeforeClassAndAfterClassAnnotationsUnitTest.class);
+
+    @BeforeClass
+    public static void setup() {
+        LOG.debug("startup - creating DB connection");
+    }
+
+    @AfterClass
+    public static void tearDown() {
+        LOG.debug("closing DB connection");
+    }
+
+    @Test
+    public void simpleTest() {
+        LOG.debug("simple test");
+    }
+
+    @Test
+    public void anotherSimpleTest() {
+        LOG.debug("another simple test");
+    }
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/migration/junit4/RuleExampleUnitTest.java

@@ -0,0 +1,21 @@
+package com.baeldung.migration.junit4;
+
+import com.baeldung.migration.junit4.rules.TraceUnitTestRule;
+import org.junit.Rule;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class RuleExampleUnitTest {
+    
+    private static final Logger LOGGER = LoggerFactory.getLogger(RuleExampleUnitTest.class);
+    
+    @Rule
+    public final TraceUnitTestRule traceRuleTests = new TraceUnitTestRule();
+
+    @Test
+    public void whenTracingTests() {
+        LOGGER.debug("This is my test");
+        /*...*/
+    }
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/migration/junit4/categories/Annotations.java

@@ -0,0 +1,5 @@
+package com.baeldung.migration.junit4.categories;
+
+public interface Annotations {
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/migration/junit4/categories/JUnit4UnitTest.java

@@ -0,0 +1,5 @@
+package com.baeldung.migration.junit4.categories;
+
+public interface JUnit4UnitTest {
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/migration/junit4/rules/TraceUnitTestRule.java

@@ -0,0 +1,39 @@
+package com.baeldung.migration.junit4.rules;
+
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.MultipleFailureException;
+import org.junit.runners.model.Statement;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TraceUnitTestRule implements TestRule {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(TraceUnitTestRule.class);
+
+    @Override
+    public Statement apply(Statement base, Description description) {
+
+        return new Statement() {
+            @Override
+            public void evaluate() throws Throwable {
+                List<Throwable> errors = new ArrayList<Throwable>();
+
+                LOGGER.debug("Starting test ... {}", description.getMethodName());
+                try {
+                    base.evaluate();
+                } catch (Throwable e) {
+                    errors.add(e);
+                } finally {
+                    LOGGER.debug("... test finished. {}", description.getMethodName());
+                }
+
+                MultipleFailureException.assertEmpty(errors);
+            }
+        };
+    }
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/migration/junit5/AnnotationTestExampleUnitTest.java

@@ -0,0 +1,26 @@
+package com.baeldung.migration.junit5;
+
+import java.time.Duration;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+@Tag("annotations")
+@Tag("junit5")
+class AnnotationTestExampleUnitTest {
+
+    @Test
+    void shouldRaiseAnException() {
+        Assertions.assertThrows(Exception.class, () -> {
+            throw new Exception("This is my expected exception");
+        });
+    }
+
+    @Test
+    @Disabled
+    void shouldFailBecauseTimeout() {
+        Assertions.assertTimeout(Duration.ofMillis(1), () -> Thread.sleep(10));
+    }
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/migration/junit5/AssertionsExampleUnitTest.java

@@ -0,0 +1,35 @@
+package com.baeldung.migration.junit5;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+public class AssertionsExampleUnitTest {
+
+    @Test
+    @Disabled
+    void shouldFailBecauseTheNumbersAreNotEqual() {
+        Assertions.assertEquals(2, 3, "Numbers are not equal!");
+    }
+
+    @Test
+    @Disabled
+    void shouldFailBecauseItsNotTrue_overloading() {
+        Assertions.assertTrue(() -> {
+            return false;
+        }, () -> "It's not true!");
+    }
+
+    @Test
+    void shouldAssertAllTheGroup() {
+        List<Integer> list = Arrays.asList(1, 2, 3);
+
+        Assertions.assertAll("List is not incremental",
+          () -> Assertions.assertEquals(list.get(0).intValue(), 1),
+          () -> Assertions.assertEquals(list.get(1).intValue(), 2),
+          () -> Assertions.assertEquals(list.get(2).intValue(), 3));
+    }
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/migration/junit5/AssumptionUnitTest.java

@@ -0,0 +1,27 @@
+package com.baeldung.migration.junit5;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assumptions.*;
+
+class AssumptionUnitTest {
+
+    @Test
+    void trueAssumption() {
+        assumeTrue(5 > 1, () -> "5 is greater the 1");
+        assertEquals(5 + 2, 7);
+    }
+
+    @Test
+    void falseAssumption() {
+        assumeFalse(5 < 1, () -> "5 is less then 1");
+        assertEquals(5 + 2, 7);
+    }
+
+    @Test
+    void assumptionThat() {
+        String someString = "Just a string";
+        assumingThat(someString.equals("Just a string"), () -> assertEquals(2 + 2, 4));
+    }
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/migration/junit5/BeforeAllAndAfterAllAnnotationsUnitTest.java

@@ -0,0 +1,32 @@
+package com.baeldung.migration.junit5;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+class BeforeAllAndAfterAllAnnotationsUnitTest {
+
+    private static final Logger LOG = LoggerFactory.getLogger(BeforeAllAndAfterAllAnnotationsUnitTest.class);
+
+    @BeforeAll
+    static void setup() {
+        LOG.debug("startup - creating DB connection");
+    }
+
+    @AfterAll
+    static void tearDown() {
+        LOG.debug("closing DB connection");
+    }
+
+    @Test
+    void simpleTest() {
+        LOG.debug("simple test");
+    }
+
+    @Test
+    void anotherSimpleTest() {
+        LOG.debug("another simple test");
+    }
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/migration/junit5/BeforeEachAndAfterEachAnnotationsUnitTest.java

@@ -0,0 +1,48 @@
+package com.baeldung.migration.junit5;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class BeforeEachAndAfterEachAnnotationsUnitTest {
+
+    private static final Logger LOG = LoggerFactory.getLogger(BeforeEachAndAfterEachAnnotationsUnitTest.class);
+
+    private List<String> list;
+
+    @BeforeEach
+    void init() {
+        LOG.debug("startup");
+        list = new ArrayList<>(Arrays.asList("test1", "test2"));
+    }
+
+    @AfterEach
+    void teardown() {
+        LOG.debug("teardown");
+        list.clear();
+    }
+
+    @Test
+    void whenCheckingListSize_thenSizeEqualsToInit() {
+        LOG.debug("executing test");
+        assertEquals(2, list.size());
+
+        list.add("another test");
+    }
+
+    @Test
+    public void whenCheckingListSizeAgain_thenSizeEqualsToInit() {
+        LOG.debug("executing another test");
+        assertEquals(2, list.size());
+
+        list.add("yet another test");
+    }
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/migration/junit5/RuleExampleUnitTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.migration.junit5;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.baeldung.migration.junit5.extensions.TraceUnitExtension;
+
+@ExtendWith(TraceUnitExtension.class)
+class RuleExampleUnitTest {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(RuleExampleUnitTest.class);
+
+    @Test
+    void whenTracingTests() {
+       LOGGER.debug("This is my test");
+        /*...*/
+    }
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/migration/junit5/extensions/TraceUnitExtension.java

@@ -0,0 +1,23 @@
+package com.baeldung.migration.junit5.extensions;
+
+import org.junit.jupiter.api.extension.AfterEachCallback;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TraceUnitExtension implements AfterEachCallback, BeforeEachCallback {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(TraceUnitExtension.class);
+
+    @Override
+    public void beforeEach(ExtensionContext context) throws Exception {
+        LOGGER.debug("Starting test ... {}", context.getDisplayName());
+    }
+
+    @Override
+    public void afterEach(ExtensionContext context) throws Exception {
+        LOGGER.debug("... test finished. {}", context.getDisplayName());
+    }
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/resourcedirectory/ReadResourceDirectoryUnitTest.java

@@ -0,0 +1,50 @@
+package com.baeldung.resourcedirectory;
+
+import com.baeldung.migration.junit5.extensions.TraceUnitExtension;
+import org.junit.Assert;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public class ReadResourceDirectoryUnitTest {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(TraceUnitExtension.class);
+    
+    @Test
+    public void givenResourcePath_whenReadAbsolutePathWithFile_thenAbsolutePathEndsWithDirectory() {
+        String path = "src/test/resources";
+
+        File file = new File(path);
+        String absolutePath = file.getAbsolutePath();
+
+        LOGGER.debug(absolutePath);
+        Assert.assertTrue(absolutePath.endsWith("src" + File.separator + "test" + File.separator + "resources"));
+    }
+
+    @Test
+    public void givenResourcePath_whenReadAbsolutePathWithPaths_thenAbsolutePathEndsWithDirectory() {
+        Path resourceDirectory = Paths.get("src", "test", "resources");
+
+        String absolutePath = resourceDirectory.toFile().getAbsolutePath();
+
+        LOGGER.debug(absolutePath);
+        Assert.assertTrue(absolutePath.endsWith("src" + File.separator + "test" + File.separator + "resources"));
+    }
+
+    @Test
+    public void givenResourceFile_whenReadResourceWithClassLoader_thenPathEndWithFilename() {
+        String resourceName = "example_resource.txt";
+
+        ClassLoader classLoader = getClass().getClassLoader();
+        File file = new File(classLoader.getResource(resourceName).getFile());
+        String absolutePath = file.getAbsolutePath();
+
+        LOGGER.debug(absolutePath);
+        Assert.assertTrue(absolutePath.endsWith(File.separator + "example_resource.txt"));
+    }
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/suites/AllUnitTest.java

@@ -0,0 +1,13 @@
+package com.baeldung.suites;
+
+import org.junit.platform.suite.api.ExcludePackages;
+import org.junit.platform.suite.api.SelectPackages;
+import org.junit.platform.suite.api.Suite;
+
+@Suite
+@SelectPackages("com.baeldung")
+@ExcludePackages("com.baeldung.suites")
+public class AllUnitTest {
+
+}
+ 

testing-modules/junit-5-basics/src/test/java/com/baeldung/tags/EmployeeDAOIntegrationTest.java

@@ -0,0 +1,69 @@
+package com.baeldung.tags;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.annotation.DirtiesContext.ClassMode;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import com.baeldung.junit.tags.example.Employee;
+import com.baeldung.junit.tags.example.EmployeeDAO;
+import com.baeldung.junit.tags.example.SpringJdbcConfig;
+
+@ExtendWith(SpringExtension.class)
+@ContextConfiguration(classes = { SpringJdbcConfig.class }, loader = AnnotationConfigContextLoader.class)
+@DirtiesContext(classMode = ClassMode.BEFORE_EACH_TEST_METHOD)
+public class EmployeeDAOIntegrationTest {
+
+    @Autowired
+    private EmployeeDAO employeeDao;
+
+    @Mock
+    private JdbcTemplate jdbcTemplate;
+    private EmployeeDAO employeeDAO;
+
+    @BeforeEach
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        employeeDAO = new EmployeeDAO();
+        employeeDAO.setJdbcTemplate(jdbcTemplate);
+    }
+
+    @Test
+    @Tag("IntegrationTest")
+    public void testAddEmployeeUsingSimpelJdbcInsert() {
+        final Employee emp = new Employee();
+        emp.setId(12);
+        emp.setFirstName("testFirstName");
+        emp.setLastName("testLastName");
+        emp.setAddress("testAddress");
+
+        Assertions.assertEquals(employeeDao.addEmplyeeUsingSimpelJdbcInsert(emp), 1);
+    }
+
+    @Test
+    @Tag("UnitTest")
+    public void givenNumberOfEmployeeWhenCountEmployeeThenCountMatch() {
+
+        // given
+        Mockito.when(jdbcTemplate.queryForObject(Mockito.any(String.class), Mockito.eq(Integer.class)))
+                .thenReturn(1);
+
+        // when
+        int countOfEmployees = employeeDAO.getCountOfEmployees();
+
+        // then
+        Assertions.assertEquals(1, countOfEmployees);
+    }
+
+}

testing-modules/junit-5-basics/src/test/java/com/baeldung/tags/EmployeeDAOTestSuite.java

@@ -0,0 +1,9 @@
+package com.baeldung.tags;
+
+import org.junit.platform.suite.api.IncludeTags;
+import org.junit.platform.suite.api.SelectPackages;
+
+@SelectPackages("com.baeldung.tags")
+@IncludeTags("UnitTest")
+public class EmployeeDAOTestSuite {
+}