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

core-java-modules/core-java-strings/src/main/java/com/baeldung/multiline/MultiLineString.java

@@ -0,0 +1,74 @@
+package com.baeldung.multiline;
+
+import com.google.common.base.Joiner;
+import com.google.common.collect.ImmutableList;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+public class MultiLineString {
+    
+    String newLine = System.getProperty("line.separator");
+    
+    public String stringConcatenation() {
+        return "Get busy living"
+                .concat(newLine)
+                .concat("or")
+                .concat(newLine)
+                .concat("get busy dying.")
+                .concat(newLine)
+                .concat("--Stephen King");
+    }
+    
+    public String stringJoin() {
+        return String.join(newLine,
+                           "Get busy living",
+                           "or",
+                           "get busy dying.",
+                           "--Stephen King");
+    }
+    
+    public String stringBuilder() {
+        return new StringBuilder()
+                .append("Get busy living")
+                .append(newLine)
+                .append("or")
+                .append(newLine)
+                .append("get busy dying.")
+                .append(newLine)
+                .append("--Stephen King")
+                .toString();
+    }
+    
+    public String stringWriter() {
+        StringWriter stringWriter = new StringWriter();
+        PrintWriter printWriter = new PrintWriter(stringWriter);
+        printWriter.println("Get busy living");
+        printWriter.println("or");
+        printWriter.println("get busy dying.");
+        printWriter.println("--Stephen King");
+        return stringWriter.toString();
+    }
+    
+    public String guavaJoiner() {
+        return Joiner.on(newLine).join(ImmutableList.of("Get busy living",
+            "or",
+            "get busy dying.",
+            "--Stephen King"));
+    }
+    
+    public String loadFromFile() throws IOException {
+        return new String(Files.readAllBytes(Paths.get("src/main/resources/stephenking.txt")));
+    }
+
+    public String textBlocks() {
+        return """
+            Get busy living
+            or
+            get busy dying.
+            --Stephen King""";
+    }
+}

core-java-modules/core-java-strings/src/main/java/com/baeldung/stringIterator/StringIterator.java

@@ -0,0 +1,42 @@
+package com.baeldung.stringIterator;
+
+import java.text.*; 
+import java.util.*;
+
+public class StringIterator {
+
+    public static String javaCharArray(String str){
+        StringBuilder result = new StringBuilder();
+        for (char c : str.toCharArray()) { 
+            result.append(c);
+        }
+        return result.toString();
+    }
+
+    public static String javaforLoop(String str) {
+        StringBuilder result = new StringBuilder();
+        for (int i = 0; i < str.length(); i++) {
+            char c = str.charAt(i);
+            result.append(c);
+        }
+        return result.toString();
+    }
+
+    public static String java8forEach(String str){
+        StringBuilder result = new StringBuilder();
+        str.chars().forEach(name -> {
+            result.append((char) name);
+        });
+        return result.toString();
+    }
+
+    public static String javaCharacterIterator(String str){
+        StringBuilder result = new StringBuilder();
+        CharacterIterator it = new StringCharacterIterator(str);  
+        while (it.current() != CharacterIterator.DONE) { 
+            result.append(it.current()); 
+            it.next(); 
+        }
+        return result.toString();
+    }
+}

core-java-modules/core-java-strings/src/main/java/com/baeldung/stringbuffer/ComparePerformance.java

@@ -0,0 +1,64 @@
+package com.baeldung.stringbuffer;
+
+import java.util.concurrent.TimeUnit;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.RunnerException;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+@BenchmarkMode(Mode.SingleShotTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@Measurement(batchSize = 10000, iterations = 10)
+@Warmup(batchSize = 1000, iterations = 10)
+@State(Scope.Thread)
+public class ComparePerformance {
+
+    String strInitial = "springframework";
+    String strFinal = "";
+    String replacement = "java-";
+
+    @Benchmark
+    public String benchmarkStringConcatenation() {
+        strFinal = "";
+        strFinal += strInitial;
+        return strFinal;
+    }
+
+    @Benchmark
+    public StringBuffer benchmarkStringBufferConcatenation() {
+        StringBuffer stringBuffer = new StringBuffer(strFinal);
+        stringBuffer.append(strInitial);
+        return stringBuffer;
+    }
+
+    @Benchmark
+    public String benchmarkStringReplacement() {
+        strFinal = strInitial.replaceFirst("spring", replacement);
+        return strFinal;
+    }
+
+    @Benchmark
+    public StringBuffer benchmarkStringBufferReplacement() {
+        StringBuffer stringBuffer = new StringBuffer(strInitial);
+        stringBuffer.replace(0,6, replacement);
+        return stringBuffer;
+    }
+
+    public static void main(String[] args) throws RunnerException {
+        Options options = new OptionsBuilder()
+            .include(ComparePerformance.class.getSimpleName()).threads(1)
+            .forks(1).shouldFailOnError(true)
+            .shouldDoGC(true)
+            .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+}

core-java-modules/core-java-strings/src/main/java/com/baeldung/stringbuffer/HashCode.java

@@ -0,0 +1,24 @@
+package com.baeldung.stringbuffer;
+
+public class HashCode {
+
+    public static long getHashCodeString(String string) {
+        return string.hashCode();
+    }
+
+    public static long getHashCodeSBuffer(StringBuffer strBuff) {
+        return strBuff.hashCode();
+    }
+
+    public static void main(String[] args) {
+        String str = "Spring";
+        System.out.println("String HashCode pre concatenation :" + getHashCodeString(str));
+        str += "Framework";
+        System.out.println("String HashCode post concatenation :" + getHashCodeString(str));
+
+        StringBuffer sBuf = new StringBuffer("Spring");
+        System.out.println("StringBuffer HashCode pre concatenation :" + getHashCodeSBuffer(sBuf));
+        sBuf.append("Framework");
+        System.out.println("StringBuffer HashCode post concatenation :" + getHashCodeSBuffer(sBuf));
+    }
+}

core-java-modules/core-java-strings/src/main/java/com/baeldung/stringbuilder/ReuseStringBuilderPerformance.java

@@ -0,0 +1,55 @@
+package com.baeldung.stringbuilder;
+
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.SingleShotTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@Measurement(batchSize = 100000, iterations = 10)
+@Warmup(batchSize = 100000, iterations = 10)
+@State(Scope.Thread)
+public class ReuseStringBuilderPerformance {
+
+    @Benchmark
+    public void benchmarkStringBuilder() {
+        for (int i = 0; i < 100; i++) {
+            StringBuilder stringBuilder = new StringBuilder();
+            stringBuilder.append("baeldung");
+            stringBuilder.toString();
+        }
+    }
+
+    @Benchmark
+    public void benchmarkStringBuilderReuseWithSetLength() {
+        StringBuilder stringBuilder = new StringBuilder();
+        for (int i = 0; i < 100; i++) {
+            stringBuilder.append("baeldung");
+            stringBuilder.toString();
+            stringBuilder.setLength(0);
+        }
+    }
+
+    @Benchmark()
+    public void benchmarkStringBuilderReuseWithDelete() {
+        StringBuilder stringBuilder = new StringBuilder();
+        for (int i = 0; i < 100; i++) {
+            stringBuilder.append("baeldung");
+            stringBuilder.toString();
+            stringBuilder.delete(0, stringBuilder.length());
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        Options options = new OptionsBuilder()
+                .include(ReuseStringBuilderPerformance.class.getSimpleName()).threads(1)
+                .forks(1).shouldFailOnError(true)
+                .shouldDoGC(true)
+                .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+
+}

core-java-modules/core-java-strings/src/main/java/com/baeldung/stringperformance/StringPerformance.java

@@ -0,0 +1,198 @@
+package com.baeldung.stringperformance;
+
+import com.google.common.base.Splitter;
+import org.apache.commons.lang3.StringUtils;
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringTokenizer;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Pattern;
+
+@BenchmarkMode(Mode.SingleShotTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@Measurement(batchSize = 100000, iterations = 10)
+@Warmup(batchSize = 100000, iterations = 10)
+@State(Scope.Thread)
+public class StringPerformance {
+
+    protected String baeldung = "baeldung";
+    protected String longString = "Hello baeldung, I am a bit longer than other Strings";
+    protected String formatString = "hello %s, nice to meet you";
+    protected String formatDigit = "%d";
+    protected String emptyString = " ";
+    protected String result = "";
+
+    protected int sampleNumber = 100;
+
+    protected Pattern spacePattern = Pattern.compile(emptyString);
+    protected Pattern longPattern = Pattern.compile(longString);
+    protected List<String> stringSplit = new ArrayList<>();
+    protected List<String> stringTokenizer = new ArrayList<>();
+
+    @Benchmark
+    public String benchmarkStringDynamicConcat() {
+        result += baeldung;
+        return result;
+    }
+
+    @Benchmark
+    public StringBuilder  benchmarkStringBuilder() {
+        StringBuilder stringBuilder = new StringBuilder(result);
+        stringBuilder.append(baeldung);
+        return stringBuilder;
+    }
+
+    @Benchmark
+    public StringBuffer benchmarkStringBuffer() {
+        StringBuffer stringBuffer = new StringBuffer(result);
+        stringBuffer.append(baeldung);
+        return stringBuffer;
+    }
+
+    @Benchmark
+    public String benchmarkStringConstructor() {
+        String result = new String("baeldung");
+        return result;
+    }
+
+    @Benchmark
+    public String benchmarkStringLiteral() {
+        String result = "baeldung";
+        return result;
+    }
+
+    @Benchmark
+    public String benchmarkStringFormat_s() {
+        return String.format(formatString, baeldung);
+    }
+
+    @Benchmark
+    public String benchmarkStringConcat() {
+        result = result.concat(baeldung);
+        return result;
+    }
+
+    @Benchmark
+    public String benchmarkStringIntern() {
+        return baeldung.intern();
+    }
+
+    @Benchmark
+    public String benchmarkStringReplace() {
+        return longString.replace("average", " average !!!");
+    }
+
+    @Benchmark
+    public String benchmarkStringUtilsReplace() {
+        return StringUtils.replace(longString, "average", " average !!!");
+    }
+
+    @Benchmark
+    public List<String> benchmarkGuavaSplitter() {
+        return Splitter.on(" ").trimResults()
+                .omitEmptyStrings()
+                .splitToList(longString);
+    }
+
+    @Benchmark
+    public String [] benchmarkStringSplit() {
+        return longString.split(emptyString);
+    }
+
+    @Benchmark
+    public String [] benchmarkStringSplitPattern() {
+        return spacePattern.split(longString, 0);
+    }
+
+    @Benchmark
+    public List benchmarkStringTokenizer() {
+        StringTokenizer st = new StringTokenizer(longString);
+        while (st.hasMoreTokens()) {
+            stringTokenizer.add(st.nextToken());
+        }
+        return stringTokenizer;
+    }
+
+    @Benchmark
+    public List benchmarkStringIndexOf() {
+        int pos = 0, end;
+        while ((end = longString.indexOf(' ', pos)) >= 0) {
+            stringSplit.add(longString.substring(pos, end));
+            pos = end + 1;
+        }
+        //Add last token of string
+        stringSplit.add(longString.substring(pos));
+        return stringSplit;
+    }
+
+    @Benchmark
+    public String benchmarkIntegerToString() {
+        return Integer.toString(sampleNumber);
+    }
+
+    @Benchmark
+    public String benchmarkStringValueOf() {
+        return String.valueOf(sampleNumber);
+    }
+
+
+    @Benchmark
+    public String benchmarkStringConvertPlus() {
+        return sampleNumber + "";
+    }
+
+        @Benchmark
+    public String benchmarkStringFormat_d() {
+        return String.format(formatDigit, sampleNumber);
+    }
+
+    @Benchmark
+    public boolean benchmarkStringEquals() {
+        return longString.equals(baeldung);
+    }
+
+
+    @Benchmark
+    public boolean benchmarkStringEqualsIgnoreCase() {
+        return longString.equalsIgnoreCase(baeldung);
+    }
+
+    @Benchmark
+    public boolean benchmarkStringMatches() {
+        return longString.matches(baeldung);
+    }
+
+    @Benchmark
+    public boolean benchmarkPrecompiledMatches() {
+        return longPattern.matcher(baeldung).matches();
+    }
+
+    @Benchmark
+    public int benchmarkStringCompareTo() {
+        return longString.compareTo(baeldung);
+    }
+
+    @Benchmark
+    public boolean benchmarkStringIsEmpty() {
+        return longString.isEmpty();
+    }
+
+    @Benchmark
+    public boolean benchmarkStringLengthZero() {
+        return longString.length() == 0;
+    }
+
+    public static void main(String[] args) throws Exception {
+        Options options = new OptionsBuilder()
+                .include(StringPerformance.class.getSimpleName()).threads(1)
+                .forks(1).shouldFailOnError(true)
+                .shouldDoGC(true)
+                .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/chararraypassword/PasswordStoreExamplesUnitTest.java

@@ -0,0 +1,70 @@
+package com.baeldung.chararraypassword;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class PasswordStoreExamplesUnitTest {
+
+	String stringPassword = "password";
+	char[] charPassword = new char[]{'p', 'a', 's', 's', 'w', 'o', 'r', 'd'};
+
+	@Test
+	public void givenStringHashCode_WhenStringValueChanged_ThenHashCodesNotEqualAndValesNotEqual() {
+		String originalHashCode = Integer.toHexString(stringPassword.hashCode());
+
+		stringPassword = "********";
+		String changedHashCode = Integer.toHexString(stringPassword.hashCode());
+
+		assertThat(originalHashCode).isNotEqualTo(changedHashCode);
+		assertThat(stringPassword).isNotEqualTo("password");
+	}
+
+	@Test
+	public void givenStringHashCode_WhenStringValueChangedAndStringValueReassigned_ThenHashCodesEqualAndValesEqual() {
+		String originalHashCode = Integer.toHexString(stringPassword.hashCode());
+
+		stringPassword = "********";
+		stringPassword = "password";
+		String reassignedHashCode = Integer.toHexString(stringPassword.hashCode());
+
+		assertThat(originalHashCode).isEqualTo(reassignedHashCode);
+		assertThat(stringPassword).isEqualTo("password");
+	}
+
+	@Test
+	public void givenStringHashCode_WhenStringValueReplaced_ThenHashCodesEqualAndValesEqual() {
+		String originalHashCode = Integer.toHexString(stringPassword.hashCode());
+
+		String newString = "********";
+		stringPassword.replace(stringPassword, newString);
+
+		String hashCodeAfterReplace = Integer.toHexString(stringPassword.hashCode());
+
+		assertThat(originalHashCode).isEqualTo(hashCodeAfterReplace);
+		assertThat(stringPassword).isEqualTo("password");
+	}
+
+	@Test
+	public void givenCharArrayHashCode_WhenArrayElementsValueChanged_ThenHashCodesEqualAndValesNotEqual() {
+		String originalHashCode = Integer.toHexString(charPassword.hashCode());
+
+		Arrays.fill(charPassword, '*');
+		String changedHashCode = Integer.toHexString(charPassword.hashCode());
+
+		assertThat(originalHashCode).isEqualTo(changedHashCode);
+		assertThat(charPassword).isNotEqualTo(new char[]{'p', 'a', 's', 's', 'w', 'o', 'r', 'd'});
+	}
+
+	@Test
+	public void whenCallingToStringOfString_ThenValuesEqual() {
+		assertThat(stringPassword.toString()).isEqualTo("password");
+	}
+
+	@Test
+	public void whenCallingToStringOfCharArray_ThenValuesNotEqual() {
+		assertThat(charPassword.toString()).isNotEqualTo("password");
+	}
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/LocaleUnitTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import java.math.BigDecimal;
+import java.text.NumberFormat;
+import java.util.Locale;
+
+import static org.junit.Assert.assertEquals;
+
+public class LocaleUnitTest {
+    @Test
+    public void whenUsingLocal_thenCorrectResultsForDifferentLocale() {
+        Locale usLocale = Locale.US;
+        BigDecimal number = new BigDecimal(102_300.456d);
+         
+        NumberFormat usNumberFormat = NumberFormat.getCurrencyInstance(usLocale); 
+        assertEquals(usNumberFormat.format(number), "$102,300.46");
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringAnagramUnitTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class StringAnagramUnitTest {
+    public boolean isAnagram(String s1, String s2) {
+        if(s1.length() != s2.length())
+            return false;
+            
+        char[] arr1 = s1.toCharArray();
+        char[] arr2 = s2.toCharArray();
+        
+        Arrays.sort(arr1);
+        Arrays.sort(arr2);
+        
+        return Arrays.equals(arr1, arr2);
+    }
+    
+    @Test
+    public void whenTestAnagrams_thenTestingCorrectly() {
+        assertThat(isAnagram("car", "arc")).isTrue();
+        assertThat(isAnagram("west", "stew")).isTrue();
+        assertThat(isAnagram("west", "east")).isFalse();
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringChangeCaseUnitTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class StringChangeCaseUnitTest {
+    @Test
+    public void givenString_whenChangingToUppercase_thenCaseChanged() {
+        String s = "Welcome to Baeldung!";
+        assertEquals("WELCOME TO BAELDUNG!", s.toUpperCase());
+    }
+    
+
+    @Test
+    public void givenString_whenChangingToLowerrcase_thenCaseChanged() {
+        String s = "Welcome to Baeldung!";
+        assertEquals("welcome to baeldung!", s.toLowerCase());
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringCountOccurrencesUnitTest.java

@@ -0,0 +1,28 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class StringCountOccurrencesUnitTest {
+    public int countOccurrences(String s, char c) {
+        int count = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if (s.charAt(i) == c) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    @Test
+    public void givenString_whenCountingFrequencyOfChar_thenCountCorrect() {
+        assertEquals(3, countOccurrences("united states", 't'));
+    }
+
+    public void givenString_whenUsingJava8_thenCountingOfCharCorrect() {
+        String str = "united states";
+        long count = str.chars().filter(ch -> (char)ch == 't').count();
+        assertEquals(3, count);
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringFormatUnitTest.java

@@ -0,0 +1,14 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class StringFormatUnitTest {
+    @Test
+    public void givenString_whenUsingStringFormat_thenStringFormatted() {
+        String title = "Baeldung"; 
+        String formatted = String.format("Title is %s", title);
+        assertEquals(formatted, "Title is Baeldung");
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringInternUnitTest.java

@@ -0,0 +1,17 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class StringInternUnitTest {
+    @Test
+    public void whenCallingStringIntern_thenStringsInterned() {
+        String s1 = "Baeldung";
+        String s2 = new String("Baeldung");
+        String s3 = new String("Baeldung").intern();
+         
+        assertThat(s1 == s2).isFalse();
+        assertThat(s1 == s3).isTrue();
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringJoinerUnitTest.java

@@ -0,0 +1,19 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import java.util.StringJoiner;
+
+import static org.junit.Assert.assertEquals;
+
+public class StringJoinerUnitTest {
+    @Test
+    public void whenUsingStringJoiner_thenStringsJoined() {
+        StringJoiner joiner = new StringJoiner(",", "[", "]");
+        joiner.add("Red")
+          .add("Green")
+          .add("Blue");
+         
+        assertEquals(joiner.toString(), "[Red,Green,Blue]");
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringPalindromeUnitTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class StringPalindromeUnitTest {
+    
+    public boolean isPalindrome(String text) {
+        int forward = 0;
+        int backward = text.length() - 1;
+        while (backward > forward) {
+            char forwardChar = text.charAt(forward++);
+            char backwardChar = text.charAt(backward--);
+            if (forwardChar != backwardChar)
+                return false;
+        }
+        return true;
+    }
+    
+    @Test
+    public void givenIsPalindromeMethod_whenCheckingString_thenFindIfPalindrome() {
+        assertThat(isPalindrome("madam")).isTrue();
+        assertThat(isPalindrome("radar")).isTrue();
+        assertThat(isPalindrome("level")).isTrue();
+
+        assertThat(isPalindrome("baeldung")).isFalse();
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringReverseUnitTest.java

@@ -0,0 +1,13 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class StringReverseUnitTest {
+    @Test
+    public void whenUsingInbuildMethods_thenStringReversed() {
+        String reversed = new StringBuilder("baeldung").reverse().toString();
+        assertEquals("gnudleab", reversed);
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringSplitUnitTest.java

@@ -0,0 +1,33 @@
+package com.baeldung.interview;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class StringSplitUnitTest {
+    @Test
+    public void givenCoreJava_whenSplittingStrings_thenSplitted() {
+        String expected[] = {
+          "john",
+          "peter",
+          "mary"
+        };
+        
+        String[] splitted = "john,peter,mary".split(",");
+        assertArrayEquals( expected, splitted );
+    }
+    
+    @Test
+    public void givenApacheCommons_whenSplittingStrings_thenSplitted() {
+        String expected[] = {
+          "john",
+          "peter",
+          "mary"
+        };
+        String[] splitted = StringUtils.split("john peter mary");
+        assertArrayEquals( expected, splitted );
+    }
+    
+    
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringToByteArrayUnitTest.java

@@ -0,0 +1,24 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.StandardCharsets;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class StringToByteArrayUnitTest {
+    @Test
+    public void whenGetBytes_thenCorrect() throws UnsupportedEncodingException {
+        byte[] byteArray1 = "abcd".getBytes();
+        byte[] byteArray2 = "efgh".getBytes(StandardCharsets.US_ASCII);
+        byte[] byteArray3 = "ijkl".getBytes("UTF-8");
+        byte[] expected1 = new byte[] { 97, 98, 99, 100 };
+        byte[] expected2 = new byte[] { 101, 102, 103, 104 };
+        byte[] expected3 = new byte[] { 105, 106, 107, 108 };
+         
+        assertArrayEquals(expected1, byteArray1);
+        assertArrayEquals(expected2, byteArray2);
+        assertArrayEquals(expected3, byteArray3);
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringToCharArrayUnitTest.java

@@ -0,0 +1,17 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+
+public class StringToCharArrayUnitTest {
+    @Test
+    public void whenConvertingStringToCharArray_thenConversionSuccessful() {
+        String beforeConvStr = "hello";
+        char[] afterConvCharArr = { 'h', 'e', 'l', 'l', 'o' };
+      
+        assertEquals(Arrays.equals(beforeConvStr.toCharArray(), afterConvCharArr), true);
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/interview/StringToIntegerUnitTest.java

@@ -0,0 +1,16 @@
+package com.baeldung.interview;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class StringToIntegerUnitTest {
+    @Test
+    public void givenString_whenParsingInt_shouldConvertToInt() {
+        String givenString = "42";
+
+        int result = Integer.parseInt(givenString);
+
+        assertThat(result).isEqualTo(42);
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/multiline/MultiLineStringUnitTest.java

@@ -0,0 +1,22 @@
+package com.baeldung.multiline;
+
+import org.junit.Test;
+
+import java.io.IOException;
+
+import static org.junit.Assert.assertEquals;
+
+public class MultiLineStringUnitTest {
+
+    
+    @Test
+    public void whenCompareMultiLineStrings_thenTheyAreAllTheSame() throws IOException {
+        MultiLineString ms = new MultiLineString();
+        assertEquals(ms.stringConcatenation(), ms.stringJoin());
+        assertEquals(ms.stringJoin(), ms.stringBuilder());
+        assertEquals(ms.stringBuilder(), ms.guavaJoiner());
+        assertEquals(ms.guavaJoiner(), ms.loadFromFile());
+        assertEquals(ms.loadFromFile(), ms.textBlocks());
+    }
+    
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/passstringbyreference/Dummy.java

@@ -0,0 +1,14 @@
+package com.baeldung.passstringbyreference;
+
+public class Dummy {
+
+    String dummyString;
+
+    public String getDummyString() {
+        return dummyString;
+    }
+
+    public void setDummyString(String dummyString) {
+        this.dummyString = dummyString;
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/passstringbyreference/PassStringUnitTest.java

@@ -0,0 +1,85 @@
+package com.baeldung.passstringbyreference;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import org.junit.jupiter.api.Test;
+
+class PassStringUnitTest {
+
+    @Test
+    void givenAString_whenPassedToVoidMethod_thenStringIsNotModified() {
+        String s = "hello";
+        concatStringWithNoReturn(s);
+        assertEquals("hello", s);
+    }
+
+    void concatStringWithNoReturn(String input) {
+        input += " world";
+        assertEquals("hello world", input);
+    }
+
+    @Test
+    void givenAString_whenPassedToMethodAndReturnNewString_thenStringIsModified() {
+        String s = "hello";
+        assertEquals("hello world", concatStringWithReturn(s));
+    }
+
+    String concatStringWithReturn(String input) {
+        return input + " world";
+    }
+
+    @Test
+    void givenAString_whenPassStringBuilderToVoidMethod_thenConcatNewStringOk() {
+        StringBuilder builder = new StringBuilder("hello");
+        concatWithStringBuilder(builder);
+
+        assertEquals("hello world", builder.toString());
+    }
+
+    void concatWithStringBuilder(StringBuilder input) {
+        input.append(" world");
+    }
+
+    @Test
+    void givenAString_whenPassStringBufferToVoidMethod_thenConcatNewStringOk() {
+        StringBuffer builder = new StringBuffer("hello");
+        concatWithStringBuffer(builder);
+
+        assertEquals("hello world", builder.toString());
+    }
+
+    void concatWithStringBuffer(StringBuffer input) {
+        input.append(" world");
+    }
+
+    @Test
+    void givenObjectWithStringField_whenSetDifferentValue_thenObjectIsModified() {
+        Dummy dummy = new Dummy();
+        assertNull(dummy.getDummyString());
+        modifyStringValueInInputObject(dummy, "hello world");
+        assertEquals("hello world", dummy.getDummyString());
+    }
+
+    void modifyStringValueInInputObject(Dummy dummy, String dummyString) {
+        dummy.setDummyString(dummyString);
+    }
+
+    @Test
+    void givenObjectWithStringField_whenSetDifferentValueWithStringBuilder_thenSetStringInNewObject() {
+        assertEquals("hello world", getDummy("hello", "world").getDummyString());
+    }
+
+    Dummy getDummy(String hello, String world) {
+        StringBuilder builder = new StringBuilder();
+
+        builder.append(hello)
+          .append(" ")
+          .append(world);
+
+        Dummy dummy = new Dummy();
+        dummy.setDummyString(builder.toString());
+
+        return dummy;
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/stringIterator/StringIteratorTest.java

@@ -0,0 +1,39 @@
+package com.baeldung.stringIterator;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class StringIteratorTest {
+  
+    @Test
+    public void whenUseCharArrayMethod_thenIterate() {
+        String input = "Hello, Baeldung!";
+        String expectedOutput = "Hello, Baeldung!";
+        String result = StringIterator.javaCharArray(input);
+        assertEquals(expectedOutput, result);
+    }
+  
+    @Test
+    public void whenUseJavaForLoop_thenIterate() {
+        String input = "Hello, Baeldung!";
+        String expectedOutput = "Hello, Baeldung!";
+        String result = StringIterator.javaforLoop(input);
+        assertEquals(expectedOutput, result);
+    }
+  
+    @Test
+    public void whenUseForEachMethod_thenIterate() {
+        String input = "Hello, Baeldung!";
+        String expectedOutput = "Hello, Baeldung!";
+        String result = StringIterator.java8forEach(input);
+        assertEquals(expectedOutput, result);
+    }
+  
+    @Test
+    public void whenUseCharacterIterator_thenIterate() {
+        String input = "Hello, Baeldung!";
+        String expectedOutput = "Hello, Baeldung!";
+        String result = StringIterator.javaCharacterIterator(input);
+        assertEquals(expectedOutput, result);
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/stringbuffer/ComparePerformanceTest.java

@@ -0,0 +1,32 @@
+package com.baeldung.stringbuffer;
+
+import org.junit.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+public class ComparePerformanceTest {
+
+    ComparePerformance cp = new ComparePerformance();
+
+    @Test
+    public void whenStringConcatenated_thenResultAsExpected() {
+        assertThat(cp.benchmarkStringConcatenation()).isEqualTo("springframework");
+    }
+
+    @Test
+    public void whenStringBufferConcatenated_thenResultAsExpected() {
+        StringBuffer stringBuffer = new StringBuffer("springframework");
+        assertThat(cp.benchmarkStringBufferConcatenation()).isEqualToIgnoringCase(stringBuffer);
+    }
+
+    @Test
+    public void whenStringReplaced_thenResultAsExpected() {
+        assertThat(cp.benchmarkStringReplacement()).isEqualTo("java-framework");
+    }
+
+    @Test
+    public void whenStringBufferReplaced_thenResultAsExpected() {
+        StringBuffer stringBuffer = new StringBuffer("java-framework");
+        assertThat(cp.benchmarkStringBufferReplacement()).isEqualToIgnoringCase(stringBuffer);
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/stringbuffer/HashCodeTest.java

@@ -0,0 +1,24 @@
+package com.baeldung.stringbuffer;
+
+import org.junit.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class HashCodeTest {
+
+    String str = "Spring";
+    StringBuffer sBuf = new StringBuffer("Spring");
+
+    @Test
+    public void whenStringConcat_thenHashCodeChanges() {
+        HashCode hc = new HashCode();
+
+        long initialStringHashCode = hc.getHashCodeString(str);
+        long initialSBufHashCode =  hc.getHashCodeSBuffer(sBuf);
+
+        str += "Framework";
+        sBuf.append("Framework");
+
+        assertThat(initialStringHashCode).isNotEqualTo(hc.getHashCodeString(str));
+        assertThat(initialSBufHashCode).isEqualTo(hc.getHashCodeSBuffer(sBuf));
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/stringnotempty/StringNotEmptyUnitTest.java

@@ -0,0 +1,46 @@
+package com.baeldung.stringnotempty;
+
+import com.google.common.base.Strings;
+import org.apache.commons.lang3.StringUtils;
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.text.IsEmptyString.isEmptyOrNullString;
+import static org.hamcrest.text.IsEmptyString.isEmptyString;
+import static org.junit.Assert.*;
+
+public class StringNotEmptyUnitTest {
+
+    private String text = "baeldung";
+
+    @Test
+    public void givenAString_whenCheckedForEmptyUsingJunit_shouldAssertSuccessfully() {
+        assertTrue(!text.isEmpty());
+        assertFalse(text.isEmpty());
+        assertNotEquals("", text);
+        assertNotSame("", text);
+    }
+
+    @Test
+    public void givenAString_whenCheckedForEmptyUsingHamcrest_shouldAssertSuccessfully() {
+        assertThat(text, not(isEmptyString()));
+        assertThat(text, not(isEmptyOrNullString()));
+    }
+
+    @Test
+    public void givenAString_whenCheckedForEmptyUsingCommonsLang_shouldAssertSuccessfully() {
+        assertTrue(StringUtils.isNotBlank(text));
+    }
+
+    @Test
+    public void givenAString_whenCheckedForEmptyUsingAssertJ_shouldAssertSuccessfully() {
+        Assertions.assertThat(text).isNotEmpty();
+    }
+
+    @Test
+    public void givenAString_whenCheckedForEmptyUsingGuava_shouldAssertSuccessfully() {
+        assertFalse(Strings.isNullOrEmpty(text));
+    }
+
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/stringtoolong/StringTooLongUnitTest.java

@@ -0,0 +1,38 @@
+package com.baeldung.stringtoolong;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Properties;
+
+import org.apache.commons.io.IOUtils;
+import org.junit.Test;
+
+public class StringTooLongUnitTest {
+    @Test
+    public void whenDeclaringTooLongString_thenCompilationError() {
+        String stringTooLong = "<string too long>";  
+        assertThat(stringTooLong).isNotEmpty();
+    }
+    
+    @Test
+    public void whenStoringInFileTooLongString_thenNoCompilationError() throws IOException {
+        FileInputStream fis = new FileInputStream("src/test/resources/stringtoolong.txt");
+        String stringTooLong = IOUtils.toString(fis, "UTF-8");
+        assertThat(stringTooLong).isNotEmpty();
+    }
+    
+    @Test
+    public void whenStoringInPropertiesString_thenNoCompilationError() throws IOException {
+        String sValue = null;
+        try (InputStream input = new FileInputStream("src/test/resources/config.properties")) {
+            Properties prop = new Properties();
+            prop.load(input);
+            sValue = prop.getProperty("string.too.long");
+        }
+        assertThat(sValue).isNotEmpty();
+    }
+}
+    

core-java-modules/core-java-strings/src/test/resources/config.properties

@@ -0,0 +1 @@
+string.too.long="a long string example"