Merge branch 'master' into BAEL-5146-Validate-Serialization

core-java-modules/core-java-17/README.md

@@ -0,0 +1,3 @@
+### Relevant articles:
+
+- [Pattern Matching for Switch](https://www.baeldung.com/java-switch-pattern-matching)

core-java-modules/core-java-17/pom.xml

@@ -0,0 +1,81 @@
+<?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>core-java-17</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <name>core-java-17</name>
+    <packaging>jar</packaging>
+    <url>http://maven.apache.org</url>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../../</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+		<dependency>
+			<groupId>org.junit.jupiter</groupId>
+			<artifactId>junit-jupiter-engine</artifactId>
+			<version>${junit-jupiter.version}</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.junit.jupiter</groupId>
+			<artifactId>junit-jupiter-api</artifactId>
+			<version>${junit-jupiter.version}</version>
+			<scope>test</scope>
+		</dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <release>${maven.compiler.release}</release>
+                    <compilerArgs>--enable-preview</compilerArgs>
+                    <source>${maven.compiler.source.version}</source>
+                    <target>${maven.compiler.target.version}</target>
+                </configuration>
+            </plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-surefire-plugin</artifactId>
+				<version>${surefire.plugin.version}</version>
+				<configuration>
+					<argLine>--enable-preview</argLine>
+					<forkCount>1</forkCount>
+				</configuration>
+				<dependencies>
+					<dependency>
+						<groupId>org.apache.maven.surefire</groupId>
+						<artifactId>surefire-api</artifactId>
+						<version>${surefire.plugin.version}</version>
+					</dependency>
+				</dependencies>
+			</plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <maven.compiler.source.version>17</maven.compiler.source.version>
+        <maven.compiler.target.version>17</maven.compiler.target.version>
+		<maven.compiler.release>17</maven.compiler.release>
+		<maven-compiler-plugin.version>3.8.1</maven-compiler-plugin.version>
+		<surefire.plugin.version>3.0.0-M5</surefire.plugin.version>
+		<assertj.version>3.17.2</assertj.version>
+    </properties>
+
+</project>

core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/GuardedPatterns.java

@@ -0,0 +1,25 @@
+package com.baeldung.switchpatterns;
+
+public class GuardedPatterns {
+
+    static double getDoubleValueUsingIf(Object o) {
+        return switch (o) {
+            case String s -> {
+                if (s.length() > 0) {
+                    yield Double.parseDouble(s);
+                } else {
+                    yield 0d;
+                }
+            }
+            default -> 0d;
+        };
+    }
+
+    static double getDoubleValueUsingGuardedPatterns(Object o) {
+        return switch (o) {
+            case String s && s.length() > 0 -> Double.parseDouble(s);
+            default -> 0d;
+        };
+    }
+
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/HandlingNullValues.java

@@ -0,0 +1,20 @@
+package com.baeldung.switchpatterns;
+
+public class HandlingNullValues {
+
+    static double getDoubleUsingSwitchNullCase(Object o) {
+        return switch (o) {
+            case String s -> Double.parseDouble(s);
+            case null -> 0d;
+            default -> 0d;
+        };
+    }
+
+    static double getDoubleUsingSwitchTotalType(Object o) {
+        return switch (o) {
+            case String s -> Double.parseDouble(s);
+            case Object ob -> 0d;
+        };
+    }
+
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/ParenthesizedPatterns.java

@@ -0,0 +1,29 @@
+package com.baeldung.switchpatterns;
+
+public class ParenthesizedPatterns {
+
+    static double getDoubleValueUsingIf(Object o) {
+        return switch (o) {
+            case String s -> {
+                if (s.length() > 0) {
+                    if (s.contains("#") || s.contains("@")) {
+                        yield 0d;
+                    } else {
+                        yield Double.parseDouble(s);
+                    }
+                } else {
+                    yield 0d;
+                }
+            }
+            default -> 0d;
+        };
+    }
+
+    static double getDoubleValueUsingParenthesizedPatterns(Object o) {
+        return switch (o) {
+            case String s && s.length() > 0 && !(s.contains("#") || s.contains("@")) -> Double.parseDouble(s);
+            default -> 0d;
+        };
+    }
+
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/PatternMatching.java

@@ -0,0 +1,14 @@
+package com.baeldung.switchpatterns;
+
+public class PatternMatching {
+
+    public static void main(String[] args) {
+        Object o = args[0];
+        if (o instanceof String s) {
+            System.out.printf("Object is a string %s", s);
+        } else if(o instanceof Number n) {
+            System.out.printf("Object is a number %n", n);
+        }
+    }
+
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/SwitchStatement.java

@@ -0,0 +1,14 @@
+package com.baeldung.switchpatterns;
+
+public class SwitchStatement {
+
+    public static void main(String[] args) {
+        final String b = "B";
+        switch (args[0]) {
+            case "A" -> System.out.println("Parameter is A");
+            case b -> System.out.println("Parameter is b");
+            default -> System.out.println("Parameter is unknown");
+        };
+    }
+
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/switchpatterns/TypePatterns.java

@@ -0,0 +1,30 @@
+package com.baeldung.switchpatterns;
+
+public class TypePatterns {
+
+    static double getDoubleUsingIf(Object o) {
+        double result;
+
+        if (o instanceof Integer) {
+            result = ((Integer) o).doubleValue();
+        } else if (o instanceof Float) {
+            result = ((Float) o).doubleValue();
+        } else if (o instanceof String) {
+            result = Double.parseDouble(((String) o));
+        } else {
+            result = 0d;
+        }
+
+        return result;
+    }
+
+    static double getDoubleUsingSwitch(Object o) {
+        return switch (o) {
+            case Integer i -> i.doubleValue();
+            case Float f -> f.doubleValue();
+            case String s -> Double.parseDouble(s);
+            default -> 0d;
+        };
+    }
+
+}

core-java-modules/core-java-17/src/test/java/com/baeldung/switchpatterns/GuardedPatternsUnitTest.java

@@ -0,0 +1,30 @@
+package com.baeldung.switchpatterns;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static com.baeldung.switchpatterns.GuardedPatterns.*;
+
+class GuardedPatternsUnitTest {
+
+    @Test
+    void givenIfImplementation_whenUsingEmptyString_thenDoubleIsReturned() {
+        assertEquals(0d, getDoubleValueUsingIf(""));
+    }
+
+    @Test
+    void givenIfImplementation_whenUsingNonEmptyString_thenDoubleIsReturned() {
+        assertEquals(10d, getDoubleValueUsingIf("10"));
+    }
+
+    @Test
+    void givenPatternsImplementation_whenUsingEmptyString_thenDoubleIsReturned() {
+        assertEquals(0d, getDoubleValueUsingGuardedPatterns(""));
+    }
+
+    @Test
+    void givenPatternsImplementation_whenUsingNonEmptyString_thenDoubleIsReturned() {
+        assertEquals(10d, getDoubleValueUsingGuardedPatterns("10"));
+    }
+
+}

core-java-modules/core-java-17/src/test/java/com/baeldung/switchpatterns/HandlingNullValuesUnitTest.java

@@ -0,0 +1,30 @@
+package com.baeldung.switchpatterns;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static com.baeldung.switchpatterns.HandlingNullValues.*;
+
+class HandlingNullValuesUnitTest {
+
+    @Test
+    void givenNullCaseInSwitch_whenUsingStringAsArgument_thenDoubleIsReturned() {
+        assertEquals(10d, getDoubleUsingSwitchNullCase("10"));
+    }
+
+    @Test
+    void givenTotalTypeInSwitch_whenUsingNullArgument_thenDoubleIsReturned() {
+        assertEquals(0d, getDoubleUsingSwitchNullCase(null));
+    }
+
+    @Test
+    void givenTotalTypeInSwitch_whenUsingStringAsArgument_thenDoubleIsReturned() {
+        assertEquals(10d, getDoubleUsingSwitchTotalType("10"));
+    }
+
+    @Test
+    void givenNullCaseInSwitch_whenUsingNullArgument_thenDoubleIsReturned() {
+        assertEquals(0d, getDoubleUsingSwitchTotalType(null));
+    }
+
+}

core-java-modules/core-java-17/src/test/java/com/baeldung/switchpatterns/ParenthesizedPatternsUnitTest.java

@@ -0,0 +1,40 @@
+package com.baeldung.switchpatterns;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static com.baeldung.switchpatterns.ParenthesizedPatterns.*;
+
+class ParenthesizedPatternsUnitTest {
+
+    @Test
+    void givenIfImplementation_whenUsingEmptyString_thenDoubleIsReturned() {
+        assertEquals(0d, getDoubleValueUsingIf(""));
+    }
+
+    @Test
+    void givenIfImplementation_whenUsingNonEmptyString_thenDoubleIsReturned() {
+        assertEquals(10d, getDoubleValueUsingIf("10"));
+    }
+
+    @Test
+    void givenIfImplementation_whenStringContainsSpecialChar_thenDoubleIsReturned() {
+        assertEquals(0d, getDoubleValueUsingIf("@10"));
+    }
+
+    @Test
+    void givenPatternsImplementation_whenUsingEmptyString_thenDoubleIsReturned() {
+        assertEquals(0d, getDoubleValueUsingParenthesizedPatterns(""));
+    }
+
+    @Test
+    void givenPatternsImplementation_whenUsingNonEmptyString_thenDoubleIsReturned() {
+        assertEquals(10d, getDoubleValueUsingParenthesizedPatterns("10"));
+    }
+
+    @Test
+    void givenPatternsImplementation_whenStringContainsSpecialChar_thenDoubleIsReturned() {
+        assertEquals(0d, getDoubleValueUsingParenthesizedPatterns("@10"));
+    }
+
+}

core-java-modules/core-java-17/src/test/java/com/baeldung/switchpatterns/TypePatternsUnitTest.java

@@ -0,0 +1,49 @@
+package com.baeldung.switchpatterns;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static com.baeldung.switchpatterns.TypePatterns.*;
+
+class TypePatternsUnitTest {
+
+    @Test
+    void givenIfImplementation_whenUsingIntegerAsArgument_thenDoubleIsReturned() {
+        assertEquals(10d, getDoubleUsingIf(10));
+    }
+
+    @Test
+    void givenIfImplementation_whenUsingDoubleAsArgument_thenDoubleIsReturned() {
+        assertEquals(10d, getDoubleUsingIf(10.0f));
+    }
+
+    @Test
+    void givenIfImplementation_whenUsingStringAsArgument_thenDoubleIsReturned() {
+        assertEquals(10d, getDoubleUsingIf("10"));
+    }
+
+    @Test
+    void givenIfImplementation_whenUsingCharAsArgument_thenDoubleIsReturned() {
+        assertEquals(0d, getDoubleUsingIf('c'));
+    }
+
+    @Test
+    void givenSwitchImplementation_whenUsingIntegerAsArgument_thenDoubleIsReturned() {
+        assertEquals(10d, getDoubleUsingSwitch(10));
+    }
+
+    @Test
+    void givenSwitchImplementation_whenUsingDoubleAsArgument_thenDoubleIsReturned() {
+        assertEquals(10d, getDoubleUsingSwitch(10.0f));
+    }
+
+    @Test
+    void givenSwitchImplementation_whenUsingStringAsArgument_thenDoubleIsReturned() {
+        assertEquals(10d, getDoubleUsingSwitch("10"));
+    }
+
+    @Test
+    void givenSwitchImplementation_whenUsingCharAsArgument_thenDoubleIsReturned() {
+        assertEquals(0d, getDoubleUsingSwitch('c'));
+    }
+
+}

core-java-modules/core-java-arrays-convert/README.md

@@ -5,3 +5,4 @@ This module contains articles about arrays conversion in Java
 ## Relevant Articles
 - [Convert a Float to a Byte Array in Java](https://www.baeldung.com/java-convert-float-to-byte-array)
 - [Converting Between Stream and Array in Java](https://www.baeldung.com/java-stream-to-array)
+- [Convert a Byte Array to a Numeric Representation in Java](https://www.baeldung.com/java-byte-array-to-number)

core-java-modules/core-java-arrays-convert/pom.xml

@@ -19,6 +19,11 @@
             <artifactId>guava</artifactId>
             <version>${guava.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
     </dependencies>
 
     <properties>

core-java-modules/core-java-arrays-convert/src/main/java/com/baeldung/array/conversions/ByteArrayToNumericRepresentation.java

@@ -0,0 +1,281 @@
+package com.baeldung.array.conversions;
+
+import com.google.common.primitives.Ints;
+import com.google.common.primitives.Longs;
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.Conversion;
+
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+
+class ByteArrayToNumericRepresentation {
+
+    static int convertByteArrayToIntUsingShiftOperator(byte[] bytes) {
+        int value = 0;
+        for (byte b : bytes) {
+            value = (value << 8) + (b & 0xFF);
+        }
+        return value;
+    }
+
+    static byte[] convertIntToByteArrayUsingShiftOperator(int value) {
+        byte[] bytes = new byte[Integer.BYTES];
+        int length = bytes.length;
+        for (int i = 0; i < length; i++) {
+            bytes[length - i - 1] = (byte) (value & 0xFF);
+            value >>= 8;
+        }
+        return bytes;
+    }
+
+    static long convertByteArrayToLongUsingShiftOperator(byte[] bytes) {
+        long value = 0;
+        for (byte b : bytes) {
+            value <<= 8;
+            value |= (b & 0xFF);
+        }
+        return value;
+    }
+
+    static byte[] convertLongToByteArrayUsingShiftOperator(long value) {
+        byte[] bytes = new byte[Long.BYTES];
+        int length = bytes.length;
+        for (int i = 0; i < length; i++) {
+            bytes[length - i - 1] = (byte) (value & 0xFF);
+            value >>= 8;
+        }
+        return bytes;
+    }
+
+    static float convertByteArrayToFloatUsingShiftOperator(byte[] bytes) {
+        // convert bytes to int
+        int intValue = 0;
+        for (byte b : bytes) {
+            intValue = (intValue << 8) + (b & 0xFF);
+        }
+
+        // convert int to float
+        return Float.intBitsToFloat(intValue);
+    }
+
+    static byte[] convertFloatToByteArrayUsingShiftOperator(float value) {
+        // convert float to int
+        int intValue = Float.floatToIntBits(value);
+
+        // convert int to bytes
+        byte[] bytes = new byte[Float.BYTES];
+        int length = bytes.length;
+        for (int i = 0; i < length; i++) {
+            bytes[length - i - 1] = (byte) (intValue & 0xFF);
+            intValue >>= 8;
+        }
+        return bytes;
+    }
+
+    static double convertingByteArrayToDoubleUsingShiftOperator(byte[] bytes) {
+        long longValue = 0;
+        for (byte b : bytes) {
+            longValue = (longValue << 8) + (b & 0xFF);
+        }
+
+        return Double.longBitsToDouble(longValue);
+    }
+
+    static byte[] convertDoubleToByteArrayUsingShiftOperator(double value) {
+        long longValue = Double.doubleToLongBits(value);
+
+        byte[] bytes = new byte[Double.BYTES];
+        int length = bytes.length;
+        for (int i = 0; i < length; i++) {
+            bytes[length - i - 1] = (byte) (longValue & 0xFF);
+            longValue >>= 8;
+        }
+        return bytes;
+    }
+
+    static int convertByteArrayToIntUsingByteBuffer(byte[] bytes) {
+        ByteBuffer buffer = ByteBuffer.allocate(Integer.BYTES);
+        buffer.put(bytes);
+        buffer.rewind();
+        return buffer.getInt();
+    }
+
+    static byte[] convertIntToByteArrayUsingByteBuffer(int value) {
+        ByteBuffer buffer = ByteBuffer.allocate(Integer.BYTES);
+        buffer.putInt(value);
+        buffer.rewind();
+        return buffer.array();
+    }
+
+    static long convertByteArrayToLongUsingByteBuffer(byte[] bytes) {
+        ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
+        buffer.put(bytes);
+        buffer.rewind();
+        return buffer.getLong();
+    }
+
+    static byte[] convertLongToByteArrayUsingByteBuffer(long value) {
+        ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
+        buffer.putLong(value);
+        buffer.rewind();
+        return buffer.array();
+    }
+
+    static float convertByteArrayToFloatUsingByteBuffer(byte[] bytes) {
+        ByteBuffer buffer = ByteBuffer.allocate(Float.BYTES);
+        buffer.put(bytes);
+        buffer.rewind();
+        return buffer.getFloat();
+    }
+
+    static byte[] convertFloatToByteArrayUsingByteBuffer(float value) {
+        ByteBuffer buffer = ByteBuffer.allocate(Float.BYTES);
+        buffer.putFloat(value);
+        buffer.rewind();
+        return buffer.array();
+    }
+
+    static double convertByteArrayToDoubleUsingByteBuffer(byte[] bytes) {
+        ByteBuffer buffer = ByteBuffer.allocate(Double.BYTES);
+        buffer.put(bytes);
+        buffer.rewind();
+        return buffer.getDouble();
+    }
+
+    static byte[] convertDoubleToByteArrayUsingByteBuffer(double value) {
+        ByteBuffer buffer = ByteBuffer.allocate(Double.BYTES);
+        buffer.putDouble(value);
+        buffer.rewind();
+        return buffer.array();
+    }
+
+    static int convertByteArrayToIntUsingBigInteger(byte[] bytes) {
+        return new BigInteger(bytes).intValue();
+    }
+
+    static byte[] convertIntToByteArrayUsingBigInteger(int value) {
+        return BigInteger.valueOf(value).toByteArray();
+    }
+
+    static long convertByteArrayToLongUsingBigInteger(byte[] bytes) {
+        return new BigInteger(bytes).longValue();
+    }
+
+    static byte[] convertLongToByteArrayUsingBigInteger(long value) {
+        return BigInteger.valueOf(value).toByteArray();
+    }
+
+    static float convertByteArrayToFloatUsingBigInteger(byte[] bytes) {
+        int intValue = new BigInteger(bytes).intValue();
+        return Float.intBitsToFloat(intValue);
+    }
+
+    static byte[] convertFloatToByteArrayUsingBigInteger(float value) {
+        int intValue = Float.floatToIntBits(value);
+        return BigInteger.valueOf(intValue).toByteArray();
+    }
+
+    static double convertByteArrayToDoubleUsingBigInteger(byte[] bytes) {
+        long longValue = new BigInteger(bytes).longValue();
+        return Double.longBitsToDouble(longValue);
+    }
+
+    static byte[] convertDoubleToByteArrayUsingBigInteger(double value) {
+        long longValue = Double.doubleToLongBits(value);
+        return BigInteger.valueOf(longValue).toByteArray();
+    }
+
+    static int convertingByteArrayToIntUsingGuava(byte[] bytes) {
+        return Ints.fromByteArray(bytes);
+    }
+
+    static byte[] convertIntToByteArrayUsingGuava(int value) {
+        return Ints.toByteArray(value);
+    }
+
+    static long convertByteArrayToLongUsingGuava(byte[] bytes) {
+        return Longs.fromByteArray(bytes);
+    }
+
+    static byte[] convertLongToByteArrayUsingGuava(long value) {
+        return Longs.toByteArray(value);
+    }
+
+    static float convertByteArrayToFloatUsingGuava(byte[] bytes) {
+        int intValue = Ints.fromByteArray(bytes);
+        return Float.intBitsToFloat(intValue);
+    }
+
+    static byte[] convertFloatToByteArrayUsingGuava(float value) {
+        int intValue = Float.floatToIntBits(value);
+        return Ints.toByteArray(intValue);
+    }
+
+    static double convertByteArrayToDoubleUsingGuava(byte[] bytes) {
+        long longValue = Longs.fromByteArray(bytes);
+        return Double.longBitsToDouble(longValue);
+    }
+
+    static byte[] convertDoubleToByteArrayUsingGuava(double value) {
+        long longValue = Double.doubleToLongBits(value);
+        return Longs.toByteArray(longValue);
+    }
+
+    static int convertByteArrayToIntUsingCommonsLang(byte[] bytes) {
+        byte[] copyBytes = Arrays.copyOf(bytes, bytes.length);
+        ArrayUtils.reverse(copyBytes);
+        return Conversion.byteArrayToInt(copyBytes, 0, 0, 0, copyBytes.length);
+    }
+
+    static byte[] convertIntToByteArrayUsingCommonsLang(int value) {
+        byte[] bytes = new byte[Integer.BYTES];
+        Conversion.intToByteArray(value, 0, bytes, 0, bytes.length);
+        ArrayUtils.reverse(bytes);
+        return bytes;
+    }
+
+    static long convertByteArrayToLongUsingCommonsLang(byte[] bytes) {
+        byte[] copyBytes = Arrays.copyOf(bytes, bytes.length);
+        ArrayUtils.reverse(copyBytes);
+        return Conversion.byteArrayToLong(copyBytes, 0, 0, 0, copyBytes.length);
+    }
+
+    static byte[] convertLongToByteArrayUsingCommonsLang(long value) {
+        byte[] bytes = new byte[Long.BYTES];
+        Conversion.longToByteArray(value, 0, bytes, 0, bytes.length);
+        ArrayUtils.reverse(bytes);
+        return bytes;
+    }
+
+    static float convertByteArrayToFloatUsingCommonsLang(byte[] bytes) {
+        byte[] copyBytes = Arrays.copyOf(bytes, bytes.length);
+        ArrayUtils.reverse(copyBytes);
+        int intValue = Conversion.byteArrayToInt(copyBytes, 0, 0, 0, copyBytes.length);
+        return Float.intBitsToFloat(intValue);
+    }
+
+    static byte[] convertFloatToByteArrayUsingCommonsLang(float value) {
+        int intValue = Float.floatToIntBits(value);
+        byte[] bytes = new byte[Float.BYTES];
+        Conversion.intToByteArray(intValue, 0, bytes, 0, bytes.length);
+        ArrayUtils.reverse(bytes);
+        return bytes;
+    }
+
+    static double convertByteArrayToDoubleUsingCommonsLang(byte[] bytes) {
+        byte[] copyBytes = Arrays.copyOf(bytes, bytes.length);
+        ArrayUtils.reverse(copyBytes);
+        long longValue = Conversion.byteArrayToLong(copyBytes, 0, 0, 0, copyBytes.length);
+        return Double.longBitsToDouble(longValue);
+    }
+
+    static byte[] convertDoubleToByteArrayUsingCommonsLang(double value) {
+        long longValue = Double.doubleToLongBits(value);
+        byte[] bytes = new byte[Long.BYTES];
+        Conversion.longToByteArray(longValue, 0, bytes, 0, bytes.length);
+        ArrayUtils.reverse(bytes);
+        return bytes;
+    }
+
+}

core-java-modules/core-java-arrays-convert/src/test/java/com/baeldung/array/conversions/ByteArrayToNumericRepresentationUnitTest.java

@@ -0,0 +1,316 @@
+package com.baeldung.array.conversions;
+
+import org.junit.Test;
+
+import static com.baeldung.array.conversions.ByteArrayToNumericRepresentation.*;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+public class ByteArrayToNumericRepresentationUnitTest {
+    private static final byte[] INT_BYTE_ARRAY = new byte[]{
+            (byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE
+    };
+    private static final int INT_VALUE = 0xCAFEBABE;
+
+
+    private static final byte[] FLOAT_BYTE_ARRAY = new byte[]{
+            (byte) 0x40, (byte) 0x48, (byte) 0xF5, (byte) 0xC3
+    };
+    private static final float FLOAT_VALUE = 3.14F;
+
+
+    private static final byte[] LONG_BYTE_ARRAY = new byte[]{
+            (byte) 0x01, (byte) 0x23, (byte) 0x45, (byte) 0x67,
+            (byte) 0x89, (byte) 0xAB, (byte) 0xCD, (byte) 0xEF
+    };
+    private static final long LONG_VALUE = 0x0123456789ABCDEFL;
+
+
+    private static final byte[] DOUBLE_BYTE_ARRAY = new byte[]{
+            (byte) 0x3F, (byte) 0xE3, (byte) 0xC6, (byte) 0xA7,
+            (byte) 0xEF, (byte) 0x9D, (byte) 0xB2, (byte) 0x2D
+    };
+    private static final double DOUBLE_VALUE = 0.618D;
+
+
+    @Test
+    public void givenShiftOperator_whenConvertingByteArrayToInt_thenSuccess() {
+        int value = convertByteArrayToIntUsingShiftOperator(INT_BYTE_ARRAY);
+
+        assertEquals(INT_VALUE, value);
+    }
+
+    @Test
+    public void givenShiftOperator_whenConvertingIntToByteArray_thenSuccess() {
+        byte[] bytes = convertIntToByteArrayUsingShiftOperator(INT_VALUE);
+
+        assertArrayEquals(INT_BYTE_ARRAY, bytes);
+    }
+
+    @Test
+    public void givenShiftOperator_whenConvertingByteArrayToLong_thenSuccess() {
+        long value = convertByteArrayToLongUsingShiftOperator(LONG_BYTE_ARRAY);
+
+        assertEquals(LONG_VALUE, value);
+    }
+
+    @Test
+    public void givenShiftOperator_whenConvertingLongToByteArray_thenSuccess() {
+        byte[] bytes = convertLongToByteArrayUsingShiftOperator(LONG_VALUE);
+
+        assertArrayEquals(LONG_BYTE_ARRAY, bytes);
+    }
+
+    @Test
+    public void givenShiftOperator_whenConvertingByteArrayToFloat_thenSuccess() {
+        float value = convertByteArrayToFloatUsingShiftOperator(FLOAT_BYTE_ARRAY);
+
+        assertEquals(Float.floatToIntBits(FLOAT_VALUE), Float.floatToIntBits(value));
+    }
+
+    @Test
+    public void givenShiftOperator_whenConvertingFloatToByteArray_thenSuccess() {
+        byte[] bytes = convertFloatToByteArrayUsingShiftOperator(FLOAT_VALUE);
+
+        assertArrayEquals(FLOAT_BYTE_ARRAY, bytes);
+    }
+
+    @Test
+    public void givenShiftOperator_whenConvertingByteArrayToDouble_thenSuccess() {
+        double value = convertingByteArrayToDoubleUsingShiftOperator(DOUBLE_BYTE_ARRAY);
+
+        assertEquals(Double.doubleToLongBits(DOUBLE_VALUE), Double.doubleToLongBits(value));
+    }
+
+    @Test
+    public void givenShiftOperator_whenConvertingDoubleToByteArray_thenSuccess() {
+        byte[] bytes = convertDoubleToByteArrayUsingShiftOperator(DOUBLE_VALUE);
+
+        assertArrayEquals(DOUBLE_BYTE_ARRAY, bytes);
+    }
+
+    @Test
+    public void givenByteBuffer_whenConvertingByteArrayToInt_thenSuccess() {
+        int value = convertByteArrayToIntUsingByteBuffer(INT_BYTE_ARRAY);
+
+        assertEquals(INT_VALUE, value);
+    }
+
+    @Test
+    public void givenByteBuffer_whenConvertingIntToByteArray_thenSuccess() {
+        byte[] bytes = convertIntToByteArrayUsingByteBuffer(INT_VALUE);
+
+        assertArrayEquals(INT_BYTE_ARRAY, bytes);
+    }
+
+    @Test
+    public void givenByteBuffer_whenConvertingByteArrayToLong_thenSuccess() {
+        long value = convertByteArrayToLongUsingByteBuffer(LONG_BYTE_ARRAY);
+
+        assertEquals(LONG_VALUE, value);
+    }
+
+    @Test
+    public void givenByteBuffer_whenConvertingLongToByteArray_thenSuccess() {
+        byte[] bytes = convertLongToByteArrayUsingByteBuffer(LONG_VALUE);
+
+        assertArrayEquals(LONG_BYTE_ARRAY, bytes);
+    }
+
+    @Test
+    public void givenByteBuffer_whenConvertingByteArrayToFloat_thenSuccess() {
+        float value = convertByteArrayToFloatUsingByteBuffer(FLOAT_BYTE_ARRAY);
+
+        assertEquals(Float.floatToIntBits(FLOAT_VALUE), Float.floatToIntBits(value));
+    }
+
+    @Test
+    public void givenByteBuffer_whenConvertingFloatToByteArray_thenSuccess() {
+        byte[] bytes = convertFloatToByteArrayUsingByteBuffer(FLOAT_VALUE);
+
+        assertArrayEquals(FLOAT_BYTE_ARRAY, bytes);
+    }
+
+    @Test
+    public void givenByteBuffer_whenConvertingByteArrayToDouble_thenSuccess() {
+        double value = convertByteArrayToDoubleUsingByteBuffer(DOUBLE_BYTE_ARRAY);
+
+        assertEquals(Double.doubleToLongBits(DOUBLE_VALUE), Double.doubleToLongBits(value));
+    }
+
+    @Test
+    public void givenByteBuffer_whenConvertingDoubleToByteArray_thenSuccess() {
+        byte[] bytes = convertDoubleToByteArrayUsingByteBuffer(DOUBLE_VALUE);
+
+        assertArrayEquals(DOUBLE_BYTE_ARRAY, bytes);
+    }
+
+    @Test
+    public void givenBigInteger_whenConvertingByteArrayToInt_thenSuccess() {
+        int value = convertByteArrayToIntUsingBigInteger(INT_BYTE_ARRAY);
+
+        assertEquals(INT_VALUE, value);
+    }
+
+    @Test
+    public void givenBigInteger_whenConvertingIntToByteArray_thenSuccess() {
+        byte[] bytes = convertIntToByteArrayUsingBigInteger(INT_VALUE);
+
+        assertArrayEquals(INT_BYTE_ARRAY, bytes);
+    }
+
+    @Test
+    public void givenBigInteger_whenConvertingByteArrayToLong_thenSuccess() {
+        long value = convertByteArrayToLongUsingBigInteger(LONG_BYTE_ARRAY);
+
+        assertEquals(LONG_VALUE, value);
+    }
+
+    @Test
+    public void givenBigInteger_whenConvertingLongToByteArray_thenSuccess() {
+        byte[] bytes = convertLongToByteArrayUsingBigInteger(LONG_VALUE);
+
+        assertArrayEquals(LONG_BYTE_ARRAY, bytes);
+    }
+
+    @Test
+    public void givenBigInteger_whenConvertingByteArrayToFloat_thenSuccess() {
+        float value = convertByteArrayToFloatUsingBigInteger(FLOAT_BYTE_ARRAY);
+
+        assertEquals(Float.floatToIntBits(FLOAT_VALUE), Float.floatToIntBits(value));
+    }
+
+    @Test
+    public void givenBigInteger_whenConvertingFloatToByteArray_thenSuccess() {
+        byte[] bytes = convertFloatToByteArrayUsingBigInteger(FLOAT_VALUE);
+
+        assertArrayEquals(FLOAT_BYTE_ARRAY, bytes);
+    }
+
+    @Test
+    public void givenBigInteger_whenConvertingByteArrayToDouble_thenSuccess() {
+        double value = convertByteArrayToDoubleUsingBigInteger(DOUBLE_BYTE_ARRAY);
+
+        assertEquals(Double.doubleToLongBits(DOUBLE_VALUE), Double.doubleToLongBits(value));
+    }
+
+    @Test
+    public void givenBigInteger_whenConvertingDoubleToByteArray_thenSuccess() {
+        byte[] bytes = convertDoubleToByteArrayUsingBigInteger(DOUBLE_VALUE);
+
+        assertArrayEquals(DOUBLE_BYTE_ARRAY, bytes);
+    }
+
+    @Test
+    public void givenGuava_whenConvertingByteArrayToInt_thenSuccess() {
+        int value = convertingByteArrayToIntUsingGuava(INT_BYTE_ARRAY);
+
+        assertEquals(INT_VALUE, value);
+    }
+
+    @Test
+    public void givenGuava_whenConvertingIntToByteArray_thenSuccess() {
+        byte[] bytes = convertIntToByteArrayUsingGuava(INT_VALUE);
+
+        assertArrayEquals(INT_BYTE_ARRAY, bytes);
+    }
+
+    @Test
+    public void givenGuava_whenConvertingByteArrayToLong_thenSuccess() {
+        long value = convertByteArrayToLongUsingGuava(LONG_BYTE_ARRAY);
+
+        assertEquals(LONG_VALUE, value);
+    }
+
+    @Test
+    public void givenGuava_whenConvertingLongToByteArray_thenSuccess() {
+        byte[] bytes = convertLongToByteArrayUsingGuava(LONG_VALUE);
+
+        assertArrayEquals(LONG_BYTE_ARRAY, bytes);
+    }
+
+    @Test
+    public void givenGuava_whenConvertingByteArrayToFloat_thenSuccess() {
+        float value = convertByteArrayToFloatUsingGuava(FLOAT_BYTE_ARRAY);
+
+        assertEquals(Float.floatToIntBits(FLOAT_VALUE), Float.floatToIntBits(value));
+    }
+
+    @Test
+    public void givenGuava_whenConvertingFloatToByteArray_thenSuccess() {
+        byte[] bytes = convertFloatToByteArrayUsingGuava(FLOAT_VALUE);
+
+        assertArrayEquals(FLOAT_BYTE_ARRAY, bytes);
+    }
+
+    @Test
+    public void givenGuava_whenConvertingByteArrayToDouble_thenSuccess() {
+        double value = convertByteArrayToDoubleUsingGuava(DOUBLE_BYTE_ARRAY);
+
+        assertEquals(Double.doubleToLongBits(DOUBLE_VALUE), Double.doubleToLongBits(value));
+    }
+
+    @Test
+    public void givenGuava_whenConvertingDoubleToByteArray_thenSuccess() {
+        byte[] bytes = convertDoubleToByteArrayUsingGuava(DOUBLE_VALUE);
+
+        assertArrayEquals(DOUBLE_BYTE_ARRAY, bytes);
+    }
+
+    @Test
+    public void givenCommonsLang_whenConvertingByteArrayToInt_thenSuccess() {
+        int value = convertByteArrayToIntUsingCommonsLang(INT_BYTE_ARRAY);
+
+        assertEquals(INT_VALUE, value);
+    }
+
+    @Test
+    public void givenCommonsLang_whenConvertingIntToByteArray_thenSuccess() {
+        byte[] bytes = convertIntToByteArrayUsingCommonsLang(INT_VALUE);
+
+        assertArrayEquals(INT_BYTE_ARRAY, bytes);
+    }
+
+    @Test
+    public void givenCommonsLang_whenConvertingByteArrayToLong_thenSuccess() {
+        long value = convertByteArrayToLongUsingCommonsLang(LONG_BYTE_ARRAY);
+
+        assertEquals(LONG_VALUE, value);
+    }
+
+    @Test
+    public void givenCommonsLang_whenConvertingLongToByteArray_thenSuccess() {
+        byte[] bytes = convertLongToByteArrayUsingCommonsLang(LONG_VALUE);
+
+        assertArrayEquals(LONG_BYTE_ARRAY, bytes);
+    }
+
+    @Test
+    public void givenCommonsLang_whenConvertingByteArrayToFloat_thenSuccess() {
+        float value = convertByteArrayToFloatUsingCommonsLang(FLOAT_BYTE_ARRAY);
+
+        assertEquals(Float.floatToIntBits(FLOAT_VALUE), Float.floatToIntBits(value));
+    }
+
+    @Test
+    public void givenCommonsLang_whenConvertingFloatToByteArray_thenSuccess() {
+        byte[] bytes = convertFloatToByteArrayUsingCommonsLang(FLOAT_VALUE);
+
+        assertArrayEquals(FLOAT_BYTE_ARRAY, bytes);
+    }
+
+    @Test
+    public void givenCommonsLang_whenConvertingByteArrayToDouble_thenSuccess() {
+        double value = convertByteArrayToDoubleUsingCommonsLang(DOUBLE_BYTE_ARRAY);
+
+        assertEquals(Double.doubleToLongBits(DOUBLE_VALUE), Double.doubleToLongBits(value));
+    }
+
+    @Test
+    public void givenCommonsLang_whenConvertingDoubleToByteArray_thenSuccess() {
+        byte[] bytes = convertDoubleToByteArrayUsingCommonsLang(DOUBLE_VALUE);
+
+        assertArrayEquals(DOUBLE_BYTE_ARRAY, bytes);
+    }
+
+}

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

@@ -6,3 +6,4 @@
 - [Split a String in Java and Keep the Delimiters](https://www.baeldung.com/java-split-string-keep-delimiters)
 - [Validate String as Filename in Java](https://www.baeldung.com/java-validate-filename)
 - [Count Spaces in a Java String](https://www.baeldung.com/java-string-count-spaces)
+- [Remove Accents and Diacritics From a String in Java](https://www.baeldung.com/java-remove-accents-from-text)

core-java-modules/core-java-string-operations-3/src/main/java/com/baeldung/accentsanddiacriticsremoval/StringNormalizer.java

@@ -0,0 +1,49 @@
+package com.baeldung.accentsanddiacriticsremoval;
+
+import org.apache.commons.lang3.StringUtils;
+
+import java.text.Normalizer;
+import java.util.StringJoiner;
+
+class StringNormalizer {
+
+    static String removeAccentsWithApacheCommons(String input) {
+        return StringUtils.stripAccents(input);
+    }
+
+    static String removeAccents(String input) {
+        return normalize(input).replaceAll("\\p{M}", "");
+    }
+
+    static String unicodeValueOfNormalizedString(String input) {
+        return toUnicode(normalize(input));
+    }
+
+    private static String normalize(String input) {
+        return input == null ? null : Normalizer.normalize(input, Normalizer.Form.NFKD);
+    }
+
+    private static String toUnicode(String input) {
+        if (input.length() == 1) {
+            return toUnicode(input.charAt(0));
+        } else {
+            StringJoiner stringJoiner = new StringJoiner(" ");
+            for (char c : input.toCharArray()) {
+                stringJoiner.add(toUnicode(c));
+            }
+            return stringJoiner.toString();
+        }
+    }
+
+    private static String toUnicode(char input) {
+
+        String hex = Integer.toHexString(input);
+        StringBuilder sb = new StringBuilder(hex);
+
+        while (sb.length() < 4) {
+            sb.insert(0, "0");
+        }
+        sb.insert(0, "\\u");
+        return sb.toString();
+    }
+}

core-java-modules/core-java-string-operations-3/src/main/java/com/baeldung/doublequotesremoval/DoubleQuotesRemovalUtils.java

@@ -0,0 +1,37 @@
+package com.baeldung.doublequotesremoval;
+
+import com.google.common.base.CharMatcher;
+
+public class DoubleQuotesRemovalUtils {
+    
+    public static String removeWithSubString(String input) {
+        if (input != null && input.length() >= 2 && input.charAt(0) == '\"' 
+            && input.charAt(input.length() - 1) == '\"') {
+            return input.substring(1, input.length() - 1);
+        }
+
+        return input;
+    }
+
+    public static String removeWithReplaceAllSimple(String input) {
+        if (input == null || input.isEmpty())
+            return input;
+
+        return input.replaceAll("\"", "");
+    }
+    
+    public static String removeWithReplaceAllAdvanced(String input) {
+        if (input == null || input.isEmpty())
+            return input;
+
+        return input.replaceAll("^\"|\"$", "");
+    }
+    
+    public static String removeWithGuava(String input) {
+        if (input == null || input.isEmpty())
+            return input;
+        
+        return CharMatcher.is('\"').trimFrom(input);
+    }
+
+}

core-java-modules/core-java-string-operations-3/src/test/java/com/baeldung/accentsanddiacriticsremoval/CollatorUnitTest.java

@@ -0,0 +1,70 @@
+package com.baeldung.accentsanddiacriticsremoval;
+
+import org.junit.Test;
+import org.openjdk.jmh.annotations.Setup;
+
+import java.text.Collator;
+
+import static java.lang.Character.*;
+import static java.lang.String.valueOf;
+import static org.junit.Assert.assertEquals;
+
+public class CollatorUnitTest {
+
+    private final Collator collator = Collator.getInstance();
+
+    @Setup
+    public void setup() {
+        collator.setDecomposition(2);
+    }
+
+    @Test
+    public void givenAccentedStringAndPrimaryCollatorStrength_whenCompareWithASCIIString_thenReturnTrue() {
+        Collator collator = Collator.getInstance();
+        collator.setDecomposition(2);
+        collator.setStrength(0);
+        assertEquals(0, collator.compare("a", "a"));
+        assertEquals(0, collator.compare("ä", "a"));
+        assertEquals(0, collator.compare("A", "a"));
+        assertEquals(1, collator.compare("b", "a"));
+        assertEquals(0, collator.compare(valueOf(toChars(0x0001)), valueOf(toChars(0x0002))));
+    }
+
+    @Test
+    public void givenAccentedStringAndSecondaryCollatorStrength_whenCompareWithASCIIString_thenReturnTrue() {
+        collator.setStrength(1);
+        assertEquals(1, collator.compare("ä", "a"));
+        assertEquals(1, collator.compare("b", "a"));
+        assertEquals(0, collator.compare("A", "a"));
+        assertEquals(0, collator.compare("a", "a"));
+        assertEquals(0, collator.compare(valueOf(toChars(0x0001)), valueOf(toChars(0x0002))));
+
+    }
+
+    @Test
+    public void givenAccentedStringAndTeriaryCollatorStrength_whenCompareWithASCIIString_thenReturnTrue() {
+        collator.setStrength(2);
+        assertEquals(1, collator.compare("A", "a"));
+        assertEquals(1, collator.compare("ä", "a"));
+        assertEquals(1, collator.compare("b", "a"));
+        assertEquals(0, collator.compare("a", "a"));
+        assertEquals(0, collator.compare(valueOf(toChars(0x0001)), valueOf(toChars(0x0002))));
+    }
+
+    @Test
+    public void givenAccentedStringAndIdenticalCollatorStrength_whenCompareWithASCIIString_thenReturnTrue() {
+        collator.setStrength(3);
+        assertEquals(1, collator.compare("A", "a"));
+        assertEquals(1, collator.compare("ä", "a"));
+        assertEquals(1, collator.compare("b", "a"));
+        assertEquals(-1, collator.compare(valueOf(toChars(0x0001)), valueOf(toChars(0x0002))));
+        assertEquals(0, collator.compare("a", "a"));
+    }
+
+    @Test
+    public void givenNondecomposableAccentedStringAndIdenticalCollatorStrength_whenCompareWithASCIIString_thenReturnTrue() {
+        collator.setStrength(0);
+        assertEquals(1, collator.compare("ł", "l"));
+        assertEquals(1, collator.compare("ø", "o"));
+    }
+}

core-java-modules/core-java-string-operations-3/src/test/java/com/baeldung/accentsanddiacriticsremoval/StringNormalizerUnitTest.java

@@ -0,0 +1,51 @@
+package com.baeldung.accentsanddiacriticsremoval;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.text.Normalizer;
+
+import org.junit.jupiter.api.Test;
+
+class StringNormalizerUnitTest {
+
+    @Test
+    public void givenNotNormalizedString_whenIsNormalized_thenReturnFalse() {
+        assertFalse(Normalizer.isNormalized("āăąēîïĩíĝġńñšŝśûůŷ", Normalizer.Form.NFKD));
+    }
+
+    @Test
+    void givenStringWithDecomposableUnicodeCharacters_whenRemoveAccents_thenReturnASCIIString() {
+        assertEquals("aaaeiiiiggnnsssuuy", StringNormalizer.removeAccents("āăąēîïĩíĝġńñšŝśûůŷ"));
+    }
+
+    @Test
+    void givenStringWithDecomposableUnicodeCharacters_whenRemoveAccentsWithApacheCommons_thenReturnASCIIString() {
+        assertEquals("aaaeiiiiggnnsssuuy", StringNormalizer.removeAccentsWithApacheCommons("āăąēîïĩíĝġńñšŝśûůŷ"));
+    }
+
+    @Test
+    void givenStringWithNondecomposableUnicodeCharacters_whenRemoveAccents_thenReturnOriginalString() {
+        assertEquals("łđħœ", StringNormalizer.removeAccents("łđħœ"));
+    }
+
+    @Test
+    void givenStringWithNondecomposableUnicodeCharacters_whenRemoveAccentsWithApacheCommons_thenReturnModifiedString() {
+        assertEquals("lđħœ", StringNormalizer.removeAccentsWithApacheCommons("łđħœ"));
+    }
+
+    @Test
+    void givenStringWithDecomposableUnicodeCharacters_whenUnicodeValueOfNormalizedString_thenReturnUnicodeValue() {
+        assertEquals("\\u0066 \\u0069", StringNormalizer.unicodeValueOfNormalizedString("fi"));
+        assertEquals("\\u0061 \\u0304", StringNormalizer.unicodeValueOfNormalizedString("ā"));
+        assertEquals("\\u0069 \\u0308", StringNormalizer.unicodeValueOfNormalizedString("ï"));
+        assertEquals("\\u006e \\u0301", StringNormalizer.unicodeValueOfNormalizedString("ń"));
+    }
+
+    @Test
+    void givenStringWithNonDecomposableUnicodeCharacters_whenUnicodeValueOfNormalizedString_thenReturnOriginalValue() {
+        assertEquals("\\u0142", StringNormalizer.unicodeValueOfNormalizedString("ł"));
+        assertEquals("\\u0127", StringNormalizer.unicodeValueOfNormalizedString("ħ"));
+        assertEquals("\\u0111", StringNormalizer.unicodeValueOfNormalizedString("đ"));
+    }
+}

core-java-modules/core-java-string-operations-3/src/test/java/com/baeldung/doublequotesremoval/DoubleQuotesRemovalUtilsUnitTest.java

@@ -0,0 +1,42 @@
+package com.baeldung.doublequotesremoval;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+public class DoubleQuotesRemovalUtilsUnitTest {
+    
+    @Test
+    public void given_EmptyString_ShouldReturn_EmptyString() {
+        String input = "";
+        
+        assertTrue(DoubleQuotesRemovalUtils.removeWithSubString(input).isEmpty());
+        assertTrue(DoubleQuotesRemovalUtils.removeWithReplaceAllSimple(input).isEmpty());
+        assertTrue(DoubleQuotesRemovalUtils.removeWithReplaceAllAdvanced(input).isEmpty());
+        assertTrue(DoubleQuotesRemovalUtils.removeWithGuava(input).isEmpty());
+    }
+    
+    @Test
+    public void given_DoubleQuotesOnly_ShouldReturn_EmptyString() {
+        String input = "\"\"";
+        
+        assertTrue(DoubleQuotesRemovalUtils.removeWithSubString(input).isEmpty());
+        assertTrue(DoubleQuotesRemovalUtils.removeWithReplaceAllSimple(input).isEmpty());
+        assertTrue(DoubleQuotesRemovalUtils.removeWithReplaceAllAdvanced(input).isEmpty());
+        assertTrue(DoubleQuotesRemovalUtils.removeWithGuava(input).isEmpty());
+    }
+    
+    @Test
+    public void given_TextWithDoubleQuotes_ShouldReturn_TextOnly() {
+        
+        String input = "\"Example of text for this test suit\"";
+        String expectedResult = "Example of text for this test suit";
+        
+        assertEquals(expectedResult, DoubleQuotesRemovalUtils.removeWithSubString(input));
+        assertEquals(expectedResult, DoubleQuotesRemovalUtils.removeWithReplaceAllSimple(input));
+        assertEquals(expectedResult, DoubleQuotesRemovalUtils.removeWithReplaceAllAdvanced(input));
+        assertEquals(expectedResult, DoubleQuotesRemovalUtils.removeWithGuava(input));
+    }
+
+}

docker/dockerfile-with-git/.gitmodules

@@ -0,0 +1,4 @@
+[submodule "project"]
+  path = project
+  url = https://github.com/eugenp/tutorials.git
+  branch = master

docker/dockerfile-with-git/Dockerfile

@@ -0,0 +1,13 @@
+ADD . /project/
+ADD /build/ /project/
+ADD /output/project.jar /project/
+
+ADD ssh-private-key /root/.ssh/id_rsa
+RUN git clone git@github.com:eugenp/tutorials.git
+
+ARG username=$GIT_USERNAME
+ARG password=$GIT_PASSWORD
+RUN git clone https://username:password@github.com:eugenp/tutorials.git
+
+VOLUME /build/ /project/
+

persistence-modules/spring-boot-persistence-h2/src/main/resources/application-lazy-load-no-trans-off.properties

@@ -5,7 +5,7 @@ spring.datasource.password=
 spring.jpa.hibernate.ddl-auto=create-drop
 spring.h2.console.enabled=true
 spring.h2.console.path=/h2-console
-spring.datasource.data=data-trans.sql
+spring.sql.init.data-locations=data-trans.sql
 
 logging.level.org.hibernate.SQL=INFO
 logging.level.org.hibernate.type=INFO

persistence-modules/spring-boot-persistence-h2/src/main/resources/application-lazy-load-no-trans-on.properties

@@ -5,7 +5,7 @@ spring.datasource.password=
 spring.jpa.hibernate.ddl-auto=create-drop
 spring.h2.console.enabled=true
 spring.h2.console.path=/h2-console
-spring.datasource.data=data-trans.sql
+spring.sql.init.data-locations=data-trans.sql
 
 logging.level.org.hibernate.SQL=INFO
 logging.level.org.hibernate.type=INFO

persistence-modules/spring-boot-persistence-h2/src/main/resources/application.yaml

@@ -0,0 +1,14 @@
+spring:
+  h2:
+    console:
+      enabled: true
+      path: /h2-console
+      console.settings.trace: false
+      spring.h2.console.settings.web-allow-others: false
+  datasource:
+    url: jdbc:h2:mem:mydb
+    username: sa
+    password: password
+    driverClassName: org.h2.Driver
+  jpa:
+    spring.jpa.database-platform: org.hibernate.dialect.H2Dialect

persistence-modules/spring-boot-persistence/src/test/resources/application.properties

@@ -13,4 +13,4 @@ hibernate.cache.use_query_cache=true
 hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory
 
 spring.jpa.properties.hibernate.hbm2ddl.import_files=import_books.sql
-spring.datasource.data=import_*_users.sql
+spring.sql.init.data-locations=import_*_users.sql

persistence-modules/spring-data-jpa-annotations/src/main/resources/ddd.properties

@@ -1 +1 @@
-spring.datasource.initialization-mode=never
+spring.sql.init.mode=never

persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/spring/data/jpa/query/UserRepositoryIntegrationTest.java

@@ -19,7 +19,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 @RunWith(SpringRunner.class)
-@DataJpaTest(properties = "spring.datasource.data=classpath:insert_users.sql")
+@DataJpaTest(properties = "spring.sql.init.data-locations=classpath:insert_users.sql")
 public class UserRepositoryIntegrationTest {
 
     @Autowired

persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/spring/data/jpa/query/datetime/ArticleRepositoryIntegrationTest.java

@@ -17,7 +17,7 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
 @RunWith(SpringRunner.class)
-@DataJpaTest(properties="spring.datasource.data=classpath:import_entities.sql")
+@DataJpaTest(properties="spring.sql.init.data-locations=classpath:import_entities.sql")
 public class ArticleRepositoryIntegrationTest {
 
     @Autowired

persistence-modules/spring-data-jpa-query/src/main/resources/application-joins.properties

@@ -1 +1 @@
-spring.datasource.data=classpath:db/import_joins.sql
+spring.sql.init.data-locations=classpath:db/import_joins.sql

persistence-modules/spring-data-jpa-repo/src/test/java/com/baeldung/boot/daos/JpaRepositoriesIntegrationTest.java

@@ -21,7 +21,7 @@ import com.baeldung.boot.domain.Location;
 import com.baeldung.boot.domain.Store;
 
 @RunWith(SpringRunner.class)
-@DataJpaTest(properties="spring.datasource.data=classpath:import_entities.sql")
+@DataJpaTest(properties="spring.sql.init.data-locations=classpath:import_entities.sql")
 public class JpaRepositoriesIntegrationTest {
     @Autowired
     private LocationRepository locationRepository;

pom.xml

@@ -1389,7 +1389,7 @@
         <hamcrest.version>2.2</hamcrest.version>
         <hamcrest-all.version>1.3</hamcrest-all.version>
         <mockito.version>3.3.0</mockito.version>
-        <byte-buddy.version>1.10.22</byte-buddy.version>
+        <byte-buddy.version>1.11.20</byte-buddy.version>
 
         <!-- logging -->
         <org.slf4j.version>1.7.30</org.slf4j.version>
@@ -1403,8 +1403,8 @@
         <java.version>1.8</java.version>
         <log4j.version>1.2.17</log4j.version>
         <esapi.version>2.2.2.0</esapi.version>
-        <jmh-core.version>1.28</jmh-core.version>
+        <jmh-core.version>1.33</jmh-core.version>
-        <jmh-generator.version>1.28</jmh-generator.version>
+        <jmh-generator.version>1.33</jmh-generator.version>
         <maven-failsafe-plugin.version>2.21.0</maven-failsafe-plugin.version>
         <commons-io.version>2.11.0</commons-io.version>
         <commons-lang.version>2.6</commons-lang.version>

ratpack/README.md

@@ -11,3 +11,4 @@ This module contains articles about Ratpack.
 - [Ratpack HTTP Client](https://www.baeldung.com/ratpack-http-client)
 - [Ratpack with RxJava](https://www.baeldung.com/ratpack-rxjava)
 - [Ratpack with Groovy](https://www.baeldung.com/ratpack-groovy)
+- [Reactive Streams API with Ratpack](https://www.baeldung.com/ratpack-reactive-streams-api)

rule-engines/evrete/README.md

@@ -0,0 +1,3 @@
+## Relevant Articles:
+
+- [Introduction to the Evrete Rule Engine](https://www.baeldung.com/java-evrete-rule-engine)

rule-engines/evrete/pom.xml

@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.baeldung.evrete</groupId>
+    <artifactId>evrete</artifactId>
+    <version>1.0</version>
+    <name>evrete</name>
+
+    <properties>
+        <evrete.version>2.1.04</evrete.version>
+    </properties>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>rule-engines</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <!-- Core library -->
+        <dependency>
+            <groupId>org.evrete</groupId>
+            <artifactId>evrete-core</artifactId>
+            <version>${evrete.version}</version>
+        </dependency>
+        <!-- Annotated Java classes -->
+        <dependency>
+            <groupId>org.evrete</groupId>
+            <artifactId>evrete-dsl-java</artifactId>
+            <version>${evrete.version}</version>
+        </dependency>
+    </dependencies>
+</project>

rule-engines/evrete/src/main/java/com/baeldung/evrete/introduction/IntroductionAJR.java

@@ -0,0 +1,47 @@
+package com.baeldung.evrete.introduction;
+
+import com.baeldung.evrete.introduction.model.Customer;
+import com.baeldung.evrete.introduction.model.Invoice;
+import org.evrete.KnowledgeService;
+import org.evrete.api.Knowledge;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.*;
+
+public class IntroductionAJR {
+    public static void main(String[] args) throws IOException {
+        ClassLoader classLoader = IntroductionAJR.class.getClassLoader();
+        KnowledgeService service = new KnowledgeService();
+        URL rulesetUrl = classLoader.getResource("rules/SalesRuleset.java");
+        Knowledge knowledge = service.newKnowledge(
+            "JAVA-SOURCE",
+            rulesetUrl
+        );
+
+        List<Customer> customers = Arrays.asList(
+            new Customer("Customer A"),
+            new Customer("Customer B"),
+            new Customer("Customer C")
+        );
+
+        Random random = new Random();
+        Collection<Object> sessionData = new LinkedList<>(customers);
+        for (int i = 0; i < 100_000; i++) {
+            Customer randomCustomer = customers.get(random.nextInt(customers.size()));
+            Invoice invoice = new Invoice(randomCustomer, 100 * random.nextDouble());
+            sessionData.add(invoice);
+        }
+
+        knowledge
+            .newStatelessSession()
+            .insert(sessionData)
+            .fire();
+
+        for (Customer c : customers) {
+            System.out.printf("%s:\t$%,.2f%n", c.getName(), c.getTotal());
+        }
+
+        service.shutdown();
+    }
+}

rule-engines/evrete/src/main/java/com/baeldung/evrete/introduction/IntroductionInline.java

@@ -0,0 +1,58 @@
+package com.baeldung.evrete.introduction;
+
+import org.evrete.KnowledgeService;
+import org.evrete.api.Knowledge;
+import com.baeldung.evrete.introduction.model.*;
+
+import java.util.*;
+
+public class IntroductionInline {
+    public static void main(String[] args) {
+        KnowledgeService service = new KnowledgeService();
+        Knowledge knowledge = service
+            .newKnowledge()
+            .newRule("Clear total sales")
+            .forEach("$c", Customer.class)
+            .execute(ctx -> {
+                Customer c = ctx.get("$c");
+                c.setTotal(0.0);
+            })
+            .newRule("Compute totals")
+            .forEach(
+                    "$c", Customer.class,
+                    "$i", Invoice.class
+            )
+            .where("$i.customer == $c")
+            .execute(ctx -> {
+                Customer c = ctx.get("$c");
+                Invoice i = ctx.get("$i");
+                c.addToTotal(i.getAmount());
+            });
+
+
+        List<Customer> customers = Arrays.asList(
+            new Customer("Customer A"),
+            new Customer("Customer B"),
+            new Customer("Customer C")
+        );
+
+        Random random = new Random();
+        Collection<Object> sessionData = new LinkedList<>(customers);
+        for (int i = 0; i < 100_000; i++) {
+            Customer randomCustomer = customers.get(random.nextInt(customers.size()));
+            Invoice invoice = new Invoice(randomCustomer, 100 * random.nextDouble());
+            sessionData.add(invoice);
+        }
+
+        knowledge
+            .newStatelessSession()
+            .insert(sessionData)
+            .fire();
+
+        for (Customer c : customers) {
+            System.out.printf("%s:\t$%,.2f%n", c.getName(), c.getTotal());
+        }
+
+        service.shutdown();
+    }
+}

rule-engines/evrete/src/main/java/com/baeldung/evrete/introduction/model/Customer.java

@@ -0,0 +1,26 @@
+package com.baeldung.evrete.introduction.model;
+
+public class Customer {
+    private double total = 0.0;
+    private final String name;
+
+    public Customer(String name) {
+        this.name = name;
+    }
+
+    public void addToTotal(double amount) {
+        this.total += amount;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public double getTotal() {
+        return total;
+    }
+
+    public void setTotal(double total) {
+        this.total = total;
+    }
+}

rule-engines/evrete/src/main/java/com/baeldung/evrete/introduction/model/Invoice.java

@@ -0,0 +1,19 @@
+package com.baeldung.evrete.introduction.model;
+
+public class Invoice {
+    private final Customer customer;
+    private final double amount;
+
+    public Invoice(Customer customer, double amount) {
+        this.customer = customer;
+        this.amount = amount;
+    }
+
+    public Customer getCustomer() {
+        return customer;
+    }
+
+    public double getAmount() {
+        return amount;
+    }
+}

rule-engines/evrete/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

rule-engines/evrete/src/main/resources/rules/SalesRuleset.java

@@ -0,0 +1,20 @@
+package org.abc.author1;
+
+import com.baeldung.evrete.introduction.model.Customer;
+import com.baeldung.evrete.introduction.model.Invoice;
+import org.evrete.dsl.annotation.Rule;
+import org.evrete.dsl.annotation.Where;
+
+public class SalesRuleset {
+
+    @Rule
+    public void rule1(Customer $c) {
+        $c.setTotal(0.0);
+    }
+
+    @Rule
+    @Where("$i.customer == $c")
+    public void rule2(Customer $c, Invoice $i) {
+        $c.addToTotal($i.getAmount());
+    }
+}

rule-engines/evrete/src/test/java/com/baeldung/evrete/introduction/IntroductionAJRUnitTest.java

@@ -0,0 +1,80 @@
+package com.baeldung.evrete.introduction;
+
+import com.baeldung.evrete.introduction.model.Customer;
+import com.baeldung.evrete.introduction.model.Invoice;
+import org.evrete.KnowledgeService;
+import org.evrete.api.Knowledge;
+import org.evrete.api.RuleSession;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.io.IOException;
+import java.util.*;
+
+class IntroductionAJRUnitTest {
+    private static KnowledgeService service;
+
+    @BeforeAll
+    static void setUpClass() {
+        service = new KnowledgeService();
+    }
+
+    @AfterAll
+    static void shutDownClass() {
+        service.shutdown();
+    }
+
+    /**
+     * This test makes sure that each customer's actual total sales is equal to the amount
+     * computed by the rule engine
+     */
+    @ParameterizedTest
+    @ValueSource(strings = {"true", "false"})
+    void sessionTotalsTest(String type) throws IOException  {
+        boolean stateful = Boolean.parseBoolean(type);
+        ClassLoader classLoader = IntroductionAJR.class.getClassLoader();
+        KnowledgeService service = new KnowledgeService();
+        Knowledge knowledge = service
+            .newKnowledge(
+                "JAVA-SOURCE",
+                classLoader.getResource("rules/SalesRuleset.java")
+            );
+
+
+        List<Customer> customers = Arrays.asList(
+            new Customer("Customer A"),
+            new Customer("Customer B"),
+            new Customer("Customer C")
+        );
+        Collection<Object> sessionData = new LinkedList<>(customers);
+
+        HashMap<Customer, Double> actualTotals = new HashMap<>();
+        Random random = new Random();
+        for (int i = 0; i < 1_000; i++) {
+            Customer randomCustomer = customers.get(random.nextInt(customers.size()));
+            Invoice invoice = new Invoice(randomCustomer, random.nextInt(100));
+            sessionData.add(invoice);
+
+            Double d = actualTotals.get(randomCustomer);
+            if(d == null) {
+                d = 0.0;
+            }
+            d = d + invoice.getAmount();
+            actualTotals.put(randomCustomer, d);
+        }
+
+        RuleSession<?> session = stateful ? knowledge.newStatefulSession() : knowledge.newStatelessSession();
+        session
+            .insert(sessionData)
+            .fire();
+
+        for(Customer c : customers) {
+            double d1 = c.getTotal();
+            double d2 = actualTotals.get(c);
+            assert d1 == d2;
+        }
+
+    }
+}

rule-engines/evrete/src/test/java/com/baeldung/evrete/introduction/IntroductionInlineUnitTest.java

@@ -0,0 +1,90 @@
+package com.baeldung.evrete.introduction;
+
+import com.baeldung.evrete.introduction.model.Customer;
+import com.baeldung.evrete.introduction.model.Invoice;
+import org.evrete.KnowledgeService;
+import org.evrete.api.Knowledge;
+import org.evrete.api.RuleSession;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.util.*;
+
+class IntroductionInlineUnitTest {
+    private static KnowledgeService service;
+
+    @BeforeAll
+    static void setUpClass() {
+        service = new KnowledgeService();
+    }
+
+    @AfterAll
+    static void shutDownClass() {
+        service.shutdown();
+    }
+
+    /**
+     * This test makes sure that each customer's actual total sales is equal to the amount
+     * computed by the rule engine
+     */
+    @ParameterizedTest
+    @ValueSource(strings = {"true", "false"})
+    void sessionTotalsTest(String type) {
+        boolean stateful = Boolean.parseBoolean(type);
+        Knowledge knowledge = service
+            .newKnowledge()
+            .newRule("Clear customer's total sales")
+            .forEach("$c", Customer.class)
+            .execute(ctx -> {
+                Customer c = ctx.get("$c");
+                c.setTotal(0.0);
+            })
+            .newRule("Compute totals")
+            .forEach(
+                    "$c", Customer.class,
+                    "$i", Invoice.class
+            )
+            .where("$i.customer == $c")
+            .execute(ctx -> {
+                Customer c = ctx.get("$c");
+                Invoice i = ctx.get("$i");
+                c.addToTotal(i.getAmount());
+            });
+
+
+        List<Customer> customers = Arrays.asList(
+            new Customer("Customer A"),
+            new Customer("Customer B"),
+            new Customer("Customer C")
+        );
+        Collection<Object> sessionData = new LinkedList<>(customers);
+
+        HashMap<Customer, Double> actualTotals = new HashMap<>();
+        Random random = new Random();
+        for (int i = 0; i < 1_000; i++) {
+            Customer randomCustomer = customers.get(random.nextInt(customers.size()));
+            Invoice invoice = new Invoice(randomCustomer, random.nextInt(100));
+            sessionData.add(invoice);
+
+            Double d = actualTotals.get(randomCustomer);
+            if(d == null) {
+                d = 0.0;
+            }
+            d = d + invoice.getAmount();
+            actualTotals.put(randomCustomer, d);
+        }
+
+        RuleSession<?> session = stateful ? knowledge.newStatefulSession() : knowledge.newStatelessSession();
+        session
+            .insert(sessionData)
+            .fire();
+
+        for(Customer c : customers) {
+            double d1 = c.getTotal();
+            double d2 = actualTotals.get(c);
+            assert d1 == d2;
+        }
+    }
+}

rule-engines/pom.xml

@@ -15,6 +15,7 @@
 
     <modules>
         <module>easy-rules</module>
+        <module>evrete</module>
         <module>openl-tablets</module>
         <module>rulebook</module>
         <!-- <module>jess</module> --> <!-- requires dependencies which are not publicly available -->

spring-boot-modules/spring-boot-environment/README.md

@@ -6,3 +6,4 @@ This module contains articles about configuring the Spring Boot `Environment`
  - [EnvironmentPostProcessor in Spring Boot](https://www.baeldung.com/spring-boot-environmentpostprocessor)
  - [Spring Properties File Outside jar](https://www.baeldung.com/spring-properties-file-outside-jar)
  - [Get the Running Port in Spring Boot](https://www.baeldung.com/spring-boot-running-port)
+ - [Environment Variable Prefixes in Spring Boot 2.5](https://www.baeldung.com/spring-boot-env-variable-prefixes)

spring-kafka/src/main/java/com/baeldung/kafka/embedded/KafkaProducerConsumerApplication.java

@@ -5,7 +5,6 @@ import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
 @SpringBootApplication
-@EnableAutoConfiguration
 public class KafkaProducerConsumerApplication {
 
     public static void main(String[] args) {

spring-kafka/src/main/java/com/baeldung/kafka/ssl/KafkaSslApplication.java

@@ -5,7 +5,6 @@ import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
 @SpringBootApplication
-@EnableAutoConfiguration
 public class KafkaSslApplication {
 
     public static void main(String[] args) {

spring-security-modules/spring-security-acl/src/main/resources/com.baeldung.acl.datasource.properties

@@ -8,5 +8,5 @@ spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
 spring.h2.console.path=/myconsole
 spring.h2.console.enabled=true
 spring.datasource.initialize=true
-spring.datasource.schema=classpath:acl-schema.sql
+spring.sql.init.schema-locations=classpath:acl-schema.sql
-spring.datasource.data=classpath:acl-data.sql
+spring.sql.init.data-locations=classpath:acl-data.sql

spring-security-modules/spring-security-web-boot-2/src/main/resources/application-mysql.properties

@@ -1,9 +1,8 @@
-spring.datasource.platform=mysql
+spring.sql.init.platform=mysql
 spring.datasource.url=jdbc:mysql://localhost:3306/jdbc_authentication
 spring.datasource.username=root
 spring.datasource.password=pass
 
-spring.datasource.initialization-mode=always
+spring.sql.init.mode=always
 spring.jpa.hibernate.ddl-auto=none
 
-spring.profiles.active=mysql

spring-security-modules/spring-security-web-boot-2/src/main/resources/application-postgre.properties

@@ -1,7 +1,7 @@
-spring.datasource.platform=postgre
+spring.sql.init.platform=postgre
 spring.datasource.url=jdbc:postgresql://localhost:5432/jdbc_authentication
 spring.datasource.username=postgres
 spring.datasource.password=pass
 
-spring.datasource.initialization-mode=always
+spring.sql.init.mode=always
 spring.jpa.hibernate.ddl-auto=none

spring-web-modules/spring-mvc-webflow/pom.xml

@@ -10,8 +10,8 @@
 
     <parent>
         <groupId>com.baeldung</groupId>
-        <artifactId>parent-modules</artifactId>
+        <artifactId>spring-web-modules</artifactId>
-        <version>1.0.0-SNAPSHOT</version>
+        <version>0.0.1-SNAPSHOT</version>
     </parent>
 
     <dependencies>

spring-web-modules/spring-mvc-xml/pom.xml

@@ -10,8 +10,8 @@
 
     <parent>
         <groupId>com.baeldung</groupId>
-        <artifactId>parent-modules</artifactId>
+        <artifactId>spring-web-modules</artifactId>
-        <version>1.0.0-SNAPSHOT</version>
+        <version>0.0.1-SNAPSHOT</version>
     </parent>
 
     <dependencies>

testing-modules/junit-4/README.md

@@ -7,3 +7,4 @@
 - [Introduction to Lambda Behave](https://www.baeldung.com/lambda-behave)
 - [Conditionally Run or Ignore Tests in JUnit 4](https://www.baeldung.com/junit-conditional-assume)
 - [JUnit 4 on How to Ignore a Base Test Class](https://www.baeldung.com/junit-ignore-base-test-class)
+- [Using Fail Assertion in JUnit](https://www.baeldung.com/junit-fail)

testing-modules/junit-5-advanced/README.md

@@ -4,3 +4,4 @@
 - [JUnit Custom Display Name Generator API](https://www.baeldung.com/junit-custom-display-name-generator)
 - [@TestInstance Annotation in JUnit 5](https://www.baeldung.com/junit-testinstance-annotation)
 - [Run JUnit Test Cases From the Command Line](https://www.baeldung.com/junit-run-from-command-line)
+- [Parallel Test Execution for JUnit 5](https://www.baeldung.com/junit-5-parallel-tests)

testing-modules/junit-5-advanced/src/test/java/com/baeldung/parallel/FirstParallelUnitTest.java

@@ -0,0 +1,21 @@
+package com.baeldung.parallel;
+
+import org.junit.jupiter.api.Test;
+
+public class FirstParallelUnitTest {
+
+    @Test
+    public void first() throws Exception{
+        System.out.println("FirstParallelUnitTest first() start => " + Thread.currentThread().getName());
+        Thread.sleep(500);
+        System.out.println("FirstParallelUnitTest first() end => " + Thread.currentThread().getName());
+    }
+
+    @Test
+    public void second() throws Exception{
+        System.out.println("FirstParallelUnitTest second() start => " + Thread.currentThread().getName());
+        Thread.sleep(500);
+        System.out.println("FirstParallelUnitTest second() end => " + Thread.currentThread().getName());
+    }
+
+}

testing-modules/junit-5-advanced/src/test/java/com/baeldung/parallel/ParallelResourceLockUnitTest.java

@@ -0,0 +1,45 @@
+package com.baeldung.parallel;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.parallel.ResourceLock;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ParallelResourceLockUnitTest {
+
+    private List<String> resources;
+
+    @BeforeEach
+    void before() {
+        resources = new ArrayList<>();
+        resources.add("test");
+    }
+
+    @AfterEach
+    void after() {
+        resources.clear();
+    }
+
+    @Test
+    @ResourceLock(value = "resources")
+    public void first() throws Exception {
+        System.out.println("ParallelResourceLockUnitTest first() start => " + Thread.currentThread().getName());
+        resources.add("first");
+        System.out.println(resources);
+        Thread.sleep(500);
+        System.out.println("ParallelResourceLockUnitTest first() end => " + Thread.currentThread().getName());
+    }
+
+    @Test
+    @ResourceLock(value = "resources")
+    public void second() throws Exception {
+        System.out.println("ParallelResourceLockUnitTest second() start => " + Thread.currentThread().getName());
+        resources.add("second");
+        System.out.println(resources);
+        Thread.sleep(500);
+        System.out.println("ParallelResourceLockUnitTest second() end => " + Thread.currentThread().getName());
+    }
+}

testing-modules/junit-5-advanced/src/test/java/com/baeldung/parallel/SecondParallelUnitTest.java

@@ -0,0 +1,21 @@
+package com.baeldung.parallel;
+
+import org.junit.jupiter.api.Test;
+
+public class SecondParallelUnitTest {
+
+    @Test
+    public void first() throws Exception{
+        System.out.println("SecondParallelUnitTest first() start => " + Thread.currentThread().getName());
+        Thread.sleep(500);
+        System.out.println("SecondParallelUnitTest first() end => " + Thread.currentThread().getName());
+    }
+
+    @Test
+    public void second() throws Exception{
+        System.out.println("SecondParallelUnitTest second() start => " + Thread.currentThread().getName());
+        Thread.sleep(500);
+        System.out.println("SecondParallelUnitTest second() end => " + Thread.currentThread().getName());
+    }
+
+}

testing-modules/junit-5-advanced/src/test/resources/junit-platform.properties

@@ -0,0 +1,4 @@
+junit.jupiter.execution.parallel.enabled = true
+junit.jupiter.execution.parallel.config.strategy=dynamic
+junit.jupiter.execution.parallel.mode.default = concurrent
+junit.jupiter.execution.parallel.mode.classes.default = concurrent

xstream/pom.xml

@@ -30,8 +30,8 @@
     </dependencies>
 
     <properties>
-        <xstream.version>1.4.10</xstream.version>
+        <xstream.version>1.4.18</xstream.version>
-        <jettison.version>1.3.8</jettison.version>
+        <jettison.version>1.4.1</jettison.version>
     </properties>
 
 </project>

xstream/src/main/java/com/baeldung/initializer/SimpleXstreamInitializer.java

@@ -7,14 +7,26 @@ import com.thoughtworks.xstream.io.json.JsonHierarchicalStreamDriver;
 public class SimpleXstreamInitializer {
 
     public XStream getXstreamInstance() {
-        return new XStream();
+        XStream xstream = new XStream();
+        xstream.allowTypesByWildcard(new String[]{
+                "com.baeldung.**"
+        });
+        return xstream;
     }
 
     public XStream getXstreamJettisonMappedInstance() {
-        return new XStream(new JettisonMappedXmlDriver());
+        XStream xstream = new XStream(new JettisonMappedXmlDriver());
+        xstream.allowTypesByWildcard(new String[]{
+                "com.baeldung.**"
+        });
+        return xstream;
     }
 
     public XStream getXstreamJsonHierarchicalInstance() {
-        return new XStream(new JsonHierarchicalStreamDriver());
+        XStream xstream = new XStream(new JsonHierarchicalStreamDriver());
+        xstream.allowTypesByWildcard(new String[]{
+                "com.baeldung.**"
+        });
+        return xstream;
     }
 }

xstream/src/test/java/com/baeldung/rce/XStreamBasicsUnitTest.java

@@ -21,6 +21,7 @@ public final class XStreamBasicsUnitTest {
     public void before() {
         xstream = new XStream();
         xstream.alias("person", Person.class);
+        xstream.allowTypes(new Class<?>[] { Person.class });
     }
 
     @Test