[BAEL-14274] - Fixed conflicts

java-strings-ops/src/test/java/com/baeldung/java/countingChars/CountCharsExampleUnitTest.java

@@ -0,0 +1,98 @@
+package com.baeldung.java.countingChars;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Test;
+
+import com.google.common.base.CharMatcher;
+
+/***
+ * Example of counting chars in a String.
+ */
+public class CountCharsExampleUnitTest {
+
+    @Test
+    public void givenString_whenUsingLoop_thenCountChars() {
+        String someString = "elephant";
+        char someChar = 'e';
+        int count = 0;
+        for (int i = 0; i < someString.length(); i++) {
+            if (someString.charAt(i) == someChar) {
+                count++;
+            }
+        }
+        assertEquals(2, count);
+    }
+
+    @Test
+    public void givenString_whenUsingReplace_thenCountChars() {
+        String someString = "elephant";
+        int count = someString.length() - someString.replace("e", "").length();
+        assertEquals(2, count);
+    }
+
+    @Test
+    public void givenString_whenUsingSplit_thenCountChars() {
+        String someString = "elephant";
+        int count = someString.split("e", -1).length - 1;
+        assertEquals(2, count);
+    }
+
+    @Test
+    public void givenString_whenUsingReqExp_thenCountChars() {
+        Pattern pattern = Pattern.compile("[^e]*e");
+        Matcher matcher = pattern.matcher("elephant");
+        int count = 0;
+        while (matcher.find()) {
+            count++;
+        }
+        assertEquals(2, count);
+    }
+
+    @Test
+    public void givenString_whenUsingRecursion_thenCountChars() {
+        int count = useRecursion("elephant", 'e', 0);
+        assertEquals(2, count);
+    }
+
+    private int useRecursion(String someString, char searchedChar, int index) {
+        if (index >= someString.length()) {
+            return 0;
+        }
+
+        int count = someString.charAt(index) == searchedChar ? 1 : 0;
+        return count + useRecursion(someString, searchedChar, index + 1);
+    }
+
+    @Test
+    public void givenString_whenUsingStringUtils_thenCountChars() throws InterruptedException {
+        int count = StringUtils.countMatches("elephant", "e");
+        assertEquals(2, count);
+    }
+
+    @Test
+    public void givenString_whenUsingJava8Features_thenCountChars() {
+        String someString = "elephant";
+        long count = someString.chars()
+            .filter(ch -> ch == 'e')
+            .count();
+        assertEquals(2, count);
+
+        long count2 = someString.codePoints()
+            .filter(ch -> ch == 'e')
+            .count();
+        assertEquals(2, count2);
+    }
+
+    @Test
+    public void givenString_whenUsingGuavaCharMatcher_thenCountChars() {
+        int count = CharMatcher.is('e')
+            .countIn("elephant");
+        assertEquals(2, count);
+    }
+
+}

java-strings-ops/src/test/java/com/baeldung/string/AppendCharAtPositionXUnitTest.java

@@ -0,0 +1,110 @@
+/**
+ * 
+ */
+package com.baeldung.string;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+/**
+ * @author swpraman
+ *
+ */
+public class AppendCharAtPositionXUnitTest {
+
+    private AppendCharAtPositionX appendCharAtPosition = new AppendCharAtPositionX();
+    private String word = "Titanc";
+    private char letter = 'i';
+
+    @Test
+    public void whenUsingCharacterArrayAndCharacterAddedAtBeginning_shouldAddCharacter() {
+        assertEquals("iTitanc", appendCharAtPosition.addCharUsingCharArray(word, letter, 0));
+    }
+
+    @Test
+    public void whenUsingSubstringAndCharacterAddedAtBeginning_shouldAddCharacter() {
+        assertEquals("iTitanc", appendCharAtPosition.addCharUsingSubstring(word, letter, 0));
+    }
+
+    @Test
+    public void whenUsingStringBuilderAndCharacterAddedAtBeginning_shouldAddCharacter() {
+        assertEquals("iTitanc", appendCharAtPosition.addCharUsingStringBuilder(word, letter, 0));
+    }
+
+    @Test
+    public void whenUsingCharacterArrayAndCharacterAddedAtMiddle_shouldAddCharacter() {
+        assertEquals("Titianc", appendCharAtPosition.addCharUsingCharArray(word, letter, 3));
+    }
+
+    @Test
+    public void whenUsingSubstringAndCharacterAddedAtMiddle_shouldAddCharacter() {
+        assertEquals("Titianc", appendCharAtPosition.addCharUsingSubstring(word, letter, 3));
+    }
+
+    @Test
+    public void whenUsingStringBuilderAndCharacterAddedAtMiddle_shouldAddCharacter() {
+        assertEquals("Titianc", appendCharAtPosition.addCharUsingStringBuilder(word, letter, 3));
+    }
+
+    @Test
+    public void whenUsingCharacterArrayAndCharacterAddedAtEnd_shouldAddCharacter() {
+        assertEquals("Titanci", appendCharAtPosition.addCharUsingCharArray(word, letter, word.length()));
+    }
+
+    @Test
+    public void whenUsingSubstringAndCharacterAddedAtEnd_shouldAddCharacter() {
+        assertEquals("Titanci", appendCharAtPosition.addCharUsingSubstring(word, letter, word.length()));
+    }
+
+    @Test
+    public void whenUsingStringBuilderAndCharacterAddedAtEnd_shouldAddCharacter() {
+        assertEquals("Titanci", appendCharAtPosition.addCharUsingStringBuilder(word, letter, word.length()));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void whenUsingCharacterArrayAndCharacterAddedAtNegativePosition_shouldThrowException() {
+        appendCharAtPosition.addCharUsingStringBuilder(word, letter, -1);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void whenUsingSubstringAndCharacterAddedAtNegativePosition_shouldThrowException() {
+        appendCharAtPosition.addCharUsingStringBuilder(word, letter, -1);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void whenUsingStringBuilderAndCharacterAddedAtNegativePosition_shouldThrowException() {
+        appendCharAtPosition.addCharUsingStringBuilder(word, letter, -1);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void whenUsingCharacterArrayAndCharacterAddedAtInvalidPosition_shouldThrowException() {
+        appendCharAtPosition.addCharUsingStringBuilder(word, letter, word.length() + 2);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void whenUsingSubstringAndCharacterAddedAtInvalidPosition_shouldThrowException() {
+        appendCharAtPosition.addCharUsingStringBuilder(word, letter, word.length() + 2);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void whenUsingStringBuilderAndCharacterAddedAtInvalidPosition_shouldThrowException() {
+        appendCharAtPosition.addCharUsingStringBuilder(word, letter, word.length() + 2);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void whenUsingCharacterArrayAndCharacterAddedAtPositionXAndStringIsNull_shouldThrowException() {
+        appendCharAtPosition.addCharUsingStringBuilder(null, letter, 3);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void whenUsingSubstringAndCharacterAddedAtPositionXAndStringIsNull_shouldThrowException() {
+        appendCharAtPosition.addCharUsingStringBuilder(null, letter, 3);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void whenUsingStringBuilderAndCharacterAddedAtPositionXAndStringIsNull_shouldThrowException() {
+        appendCharAtPosition.addCharUsingStringBuilder(null, letter, 3);
+    }
+
+}

java-strings-ops/src/test/java/com/baeldung/string/PalindromeUnitTest.java

@@ -0,0 +1,98 @@
+package com.baeldung.string;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class PalindromeUnitTest {
+
+    private String[] words = {
+            "Anna",
+            "Civic",
+            "Kayak",
+            "Level",
+            "Madam",
+    };
+
+    private String[] sentences = {
+            "Sore was I ere I saw Eros",
+            "Euston saw I was not Sue",
+            "Too hot to hoot",
+            "No mists or frost Simon",
+            "Stella won no wallets"
+    };
+
+    private Palindrome palindrome = new Palindrome();
+
+    @Test
+    public void whenWord_shouldBePalindrome() {
+        for (String word : words)
+            assertTrue(palindrome.isPalindrome(word));
+    }
+
+    @Test
+    public void whenSentence_shouldBePalindrome() {
+        for (String sentence : sentences)
+            assertTrue(palindrome.isPalindrome(sentence));
+    }
+
+    @Test
+    public void whenReverseWord_shouldBePalindrome() {
+        for (String word : words)
+            assertTrue(palindrome.isPalindromeReverseTheString(word));
+    }
+
+    @Test
+    public void whenReverseSentence_shouldBePalindrome() {
+        for (String sentence : sentences)
+            assertTrue(palindrome.isPalindromeReverseTheString(sentence));
+    }
+
+    @Test
+    public void whenStringBuilderWord_shouldBePalindrome() {
+        for (String word : words)
+            assertTrue(palindrome.isPalindromeUsingStringBuilder(word));
+    }
+
+    @Test
+    public void whenStringBuilderSentence_shouldBePalindrome() {
+        for (String sentence : sentences)
+            assertTrue(palindrome.isPalindromeUsingStringBuilder(sentence));
+    }
+
+    @Test
+    public void whenStringBufferWord_shouldBePalindrome() {
+        for (String word : words)
+            assertTrue(palindrome.isPalindromeUsingStringBuffer(word));
+    }
+
+    @Test
+    public void whenStringBufferSentence_shouldBePalindrome() {
+        for (String sentence : sentences)
+            assertTrue(palindrome.isPalindromeUsingStringBuffer(sentence));
+    }
+
+    @Test
+    public void whenPalindromeRecursive_wordShouldBePalindrome() {
+        for (String word : words)
+            assertTrue(palindrome.isPalindromeRecursive(word));
+    }
+
+    @Test
+    public void whenPalindromeRecursive_sentenceShouldBePalindrome() {
+        for (String sentence : sentences)
+            assertTrue(palindrome.isPalindromeRecursive(sentence));
+    }
+
+    @Test
+    public void whenPalindromeStreams_wordShouldBePalindrome() {
+        for (String word : words)
+            assertTrue(palindrome.isPalindromeUsingIntStream(word));
+    }
+
+    @Test
+    public void whenPalindromeStreams_sentenceShouldBePalindrome() {
+        for (String sentence : sentences)
+            assertTrue(palindrome.isPalindromeUsingIntStream(sentence));
+    }
+}

java-strings-ops/src/test/java/com/baeldung/string/SplitUnitTest.java

@@ -0,0 +1,65 @@
+package com.baeldung.string;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.jupiter.api.Test;
+
+import com.google.common.base.Splitter;
+
+public class SplitUnitTest {
+
+    @Test
+    public void givenString_whenSplit_thenReturnsArray_through_JavaLangString() {
+        assertThat("peter,james,thomas".split(",")).containsExactly("peter", "james", "thomas");
+
+        assertThat("car jeep scooter".split(" ")).containsExactly("car", "jeep", "scooter");
+
+        assertThat("1-120-232323".split("-")).containsExactly("1", "120", "232323");
+
+        assertThat("192.168.1.178".split("\\.")).containsExactly("192", "168", "1", "178");
+
+        assertThat("b a, e, l.d u, n g".split("\\s+|,\\s*|\\.\\s*")).containsExactly("b", "a", "e", "l", "d", "u", "n", "g");
+    }
+
+    @Test
+    public void givenString_whenSplit_thenReturnsArray_through_StringUtils() {
+        StringUtils.split("car jeep scooter");
+
+        assertThat(StringUtils.split("car jeep scooter")).containsExactly("car", "jeep", "scooter");
+
+        assertThat(StringUtils.split("car    jeep   scooter")).containsExactly("car", "jeep", "scooter");
+
+        assertThat(StringUtils.split("car:jeep:scooter", ":")).containsExactly("car", "jeep", "scooter");
+
+        assertThat(StringUtils.split("car.jeep.scooter", ".")).containsExactly("car", "jeep", "scooter");
+    }
+
+    @Test
+    public void givenString_whenSplit_thenReturnsList_Splitter() {
+        // given
+        List<String> resultList = Splitter.on(',')
+            .trimResults()
+            .omitEmptyStrings()
+            .splitToList("car,jeep,,   scooter");
+
+        assertThat(resultList).containsExactly("car", "jeep", "scooter");
+    }
+
+    @Test
+    public void givenStringContainsSpaces_whenSplitAndTrim_thenReturnsArray_using_Regex() {
+        assertThat(" car , jeep,  scooter ".trim()
+            .split("\\s*,\\s*")).containsExactly("car", "jeep", "scooter");
+
+    }
+
+    @Test
+    public void givenStringContainsSpaces_whenSplitAndTrim_thenReturnsArray_using_java_8() {
+        assertThat(Arrays.stream(" car , jeep,  scooter ".split(","))
+            .map(String::trim)
+            .toArray(String[]::new)).containsExactly("car", "jeep", "scooter");
+    }
+}

java-strings-ops/src/test/java/com/baeldung/string/StringComparisonUnitTest.java

@@ -0,0 +1,153 @@
+package com.baeldung.string;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Objects;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Test;
+
+public class StringComparisonUnitTest {
+
+    @Test
+    public void whenUsingComparisonOperator_ThenComparingStrings() {
+
+        String string1 = "using comparison operator";
+        String string2 = "using comparison operator";
+        String string3 = new String("using comparison operator");
+
+        assertThat(string1 == string2).isTrue();
+        assertThat(string1 == string3).isFalse();
+    }
+
+    @Test
+    public void whenUsingEqualsMethod_ThenComparingStrings() {
+
+        String string1 = "using equals method";
+        String string2 = "using equals method";
+
+        String string3 = "using EQUALS method";
+        String string4 = new String("using equals method");
+
+        assertThat(string1.equals(string2)).isTrue();
+        assertThat(string1.equals(string4)).isTrue();
+
+        assertThat(string1.equals(null)).isFalse();
+        assertThat(string1.equals(string3)).isFalse();
+    }
+
+    @Test
+    public void whenUsingEqualsIgnoreCase_ThenComparingStrings() {
+
+        String string1 = "using equals ignore case";
+        String string2 = "USING EQUALS IGNORE CASE";
+
+        assertThat(string1.equalsIgnoreCase(string2)).isTrue();
+    }
+
+    @Test
+    public void whenUsingCompareTo_ThenComparingStrings() {
+
+        String author = "author";
+        String book = "book";
+        String duplicateBook = "book";
+
+        assertThat(author.compareTo(book)).isEqualTo(-1);
+        assertThat(book.compareTo(author)).isEqualTo(1);
+        assertThat(duplicateBook.compareTo(book)).isEqualTo(0);
+    }
+
+    @Test
+    public void whenUsingCompareToIgnoreCase_ThenComparingStrings() {
+
+        String author = "Author";
+        String book = "book";
+        String duplicateBook = "BOOK";
+
+        assertThat(author.compareToIgnoreCase(book)).isEqualTo(-1);
+        assertThat(book.compareToIgnoreCase(author)).isEqualTo(1);
+        assertThat(duplicateBook.compareToIgnoreCase(book)).isEqualTo(0);
+    }
+
+    @Test
+    public void whenUsingObjectsEqualsMethod_ThenComparingStrings() {
+
+        String string1 = "using objects equals";
+        String string2 = "using objects equals";
+        String string3 = new String("using objects equals");
+
+        assertThat(Objects.equals(string1, string2)).isTrue();
+        assertThat(Objects.equals(string1, string3)).isTrue();
+
+        assertThat(Objects.equals(null, null)).isTrue();
+        assertThat(Objects.equals(null, string1)).isFalse();
+    }
+
+    @Test
+    public void whenUsingEqualsOfApacheCommons_ThenComparingStrings() {
+
+        assertThat(StringUtils.equals(null, null)).isTrue();
+        assertThat(StringUtils.equals(null, "equals method")).isFalse();
+        assertThat(StringUtils.equals("equals method", "equals method")).isTrue();
+        assertThat(StringUtils.equals("equals method", "EQUALS METHOD")).isFalse();
+    }
+
+    @Test
+    public void whenUsingEqualsIgnoreCaseOfApacheCommons_ThenComparingStrings() {
+
+        assertThat(StringUtils.equalsIgnoreCase(null, null)).isTrue();
+        assertThat(StringUtils.equalsIgnoreCase(null, "equals method")).isFalse();
+        assertThat(StringUtils.equalsIgnoreCase("equals method", "equals method")).isTrue();
+        assertThat(StringUtils.equalsIgnoreCase("equals method", "EQUALS METHOD")).isTrue();
+    }
+
+    @Test
+    public void whenUsingEqualsAnyOf_ThenComparingStrings() {
+
+        assertThat(StringUtils.equalsAny(null, null, null)).isTrue();
+        assertThat(StringUtils.equalsAny("equals any", "equals any", "any")).isTrue();
+        assertThat(StringUtils.equalsAny("equals any", null, "equals any")).isTrue();
+        assertThat(StringUtils.equalsAny(null, "equals", "any")).isFalse();
+        assertThat(StringUtils.equalsAny("equals any", "EQUALS ANY", "ANY")).isFalse();
+    }
+
+    @Test
+    public void whenUsingEqualsAnyIgnoreCase_ThenComparingStrings() {
+
+        assertThat(StringUtils.equalsAnyIgnoreCase(null, null, null)).isTrue();
+        assertThat(StringUtils.equalsAnyIgnoreCase("equals any", "equals any", "any")).isTrue();
+        assertThat(StringUtils.equalsAnyIgnoreCase("equals any", null, "equals any")).isTrue();
+        assertThat(StringUtils.equalsAnyIgnoreCase(null, "equals", "any")).isFalse();
+        assertThat(StringUtils.equalsAnyIgnoreCase("equals any ignore case", "EQUALS ANY IGNORE CASE", "any")).isTrue();
+    }
+
+    @Test
+    public void whenUsingCompare_thenComparingStringsWithNulls() {
+
+        assertThat(StringUtils.compare(null, null)).isEqualTo(0);
+        assertThat(StringUtils.compare(null, "abc")).isEqualTo(-1);
+
+        assertThat(StringUtils.compare("abc", "bbc")).isEqualTo(-1);
+        assertThat(StringUtils.compare("bbc", "abc")).isEqualTo(1);
+        assertThat(StringUtils.compare("abc", "abc")).isEqualTo(0);
+    }
+
+    @Test
+    public void whenUsingCompareIgnoreCase_ThenComparingStringsWithNulls() {
+
+        assertThat(StringUtils.compareIgnoreCase(null, null)).isEqualTo(0);
+        assertThat(StringUtils.compareIgnoreCase(null, "abc")).isEqualTo(-1);
+
+        assertThat(StringUtils.compareIgnoreCase("Abc", "bbc")).isEqualTo(-1);
+        assertThat(StringUtils.compareIgnoreCase("bbc", "ABC")).isEqualTo(1);
+        assertThat(StringUtils.compareIgnoreCase("abc", "ABC")).isEqualTo(0);
+    }
+
+    @Test
+    public void whenUsingCompareWithNullIsLessOption_ThenComparingStrings() {
+
+        assertThat(StringUtils.compare(null, "abc", true)).isEqualTo(-1);
+        assertThat(StringUtils.compare(null, "abc", false)).isEqualTo(1);
+    }
+
+}

java-strings-ops/src/test/java/com/baeldung/string/StringHelperUnitTest.java

@@ -0,0 +1,93 @@
+package com.baeldung.string;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Test;
+
+public class StringHelperUnitTest {
+
+    public static final String TEST_STRING = "abcdef";
+    public static final String NULL_STRING = null;
+    public static final String EMPTY_STRING = "";
+    public static final String ONE_CHAR_STRING = "a";
+    public static final String WHITE_SPACE_AT_THE_END_STRING = "abc ";
+    public static final String NEW_LINE_AT_THE_END_STRING = "abc\n";
+    public static final String MULTIPLE_LINES_STRING = "abc\ndef";
+
+    @Test
+    public void givenTestString_whenSubstring_thenGetStingWithoutLastChar() {
+        assertEquals("abcde", StringHelper.removeLastChar(TEST_STRING));
+        assertEquals("abcde", StringUtils.substring(TEST_STRING, 0, TEST_STRING.length() - 1));
+        assertEquals("abcde", StringUtils.chop(TEST_STRING));
+        assertEquals("abcde", TEST_STRING.replaceAll(".$", ""));
+        assertEquals("abcde", StringHelper.removeLastCharRegex(TEST_STRING));
+        assertEquals("abcde", StringHelper.removeLastCharOptional(TEST_STRING));
+        assertEquals("abcde", StringHelper.removeLastCharRegexOptional(TEST_STRING));
+    }
+
+    @Test
+    public void givenNullString_whenSubstring_thenGetNullString() {
+        assertEquals(NULL_STRING, StringHelper.removeLastChar(NULL_STRING));
+        assertEquals(NULL_STRING, StringUtils.chop(NULL_STRING));
+        assertEquals(NULL_STRING, StringHelper.removeLastCharRegex(NULL_STRING));
+        assertEquals(NULL_STRING, StringHelper.removeLastCharOptional(NULL_STRING));
+        assertEquals(NULL_STRING, StringHelper.removeLastCharRegexOptional(NULL_STRING));
+    }
+
+    @Test
+    public void givenEmptyString_whenSubstring_thenGetEmptyString() {
+        assertEquals(EMPTY_STRING, StringHelper.removeLastChar(EMPTY_STRING));
+        assertEquals(EMPTY_STRING, StringUtils.substring(EMPTY_STRING, 0, EMPTY_STRING.length() - 1));
+        assertEquals(EMPTY_STRING, StringUtils.chop(EMPTY_STRING));
+        assertEquals(EMPTY_STRING, EMPTY_STRING.replaceAll(".$", ""));
+        assertEquals(EMPTY_STRING, StringHelper.removeLastCharRegex(EMPTY_STRING));
+        assertEquals(EMPTY_STRING, StringHelper.removeLastCharOptional(EMPTY_STRING));
+        assertEquals(EMPTY_STRING, StringHelper.removeLastCharRegexOptional(EMPTY_STRING));
+    }
+
+    @Test
+    public void givenOneCharString_whenSubstring_thenGetEmptyString() {
+        assertEquals(EMPTY_STRING, StringHelper.removeLastChar(ONE_CHAR_STRING));
+        assertEquals(EMPTY_STRING, StringUtils.substring(ONE_CHAR_STRING, 0, ONE_CHAR_STRING.length() - 1));
+        assertEquals(EMPTY_STRING, StringUtils.chop(ONE_CHAR_STRING));
+        assertEquals(EMPTY_STRING, ONE_CHAR_STRING.replaceAll(".$", ""));
+        assertEquals(EMPTY_STRING, StringHelper.removeLastCharRegex(ONE_CHAR_STRING));
+        assertEquals(EMPTY_STRING, StringHelper.removeLastCharOptional(ONE_CHAR_STRING));
+        assertEquals(EMPTY_STRING, StringHelper.removeLastCharRegexOptional(ONE_CHAR_STRING));
+    }
+
+    @Test
+    public void givenStringWithWhiteSpaceAtTheEnd_whenSubstring_thenGetStringWithoutWhiteSpaceAtTheEnd() {
+        assertEquals("abc", StringHelper.removeLastChar(WHITE_SPACE_AT_THE_END_STRING));
+        assertEquals("abc", StringUtils.substring(WHITE_SPACE_AT_THE_END_STRING, 0, WHITE_SPACE_AT_THE_END_STRING.length() - 1));
+        assertEquals("abc", StringUtils.chop(WHITE_SPACE_AT_THE_END_STRING));
+        assertEquals("abc", WHITE_SPACE_AT_THE_END_STRING.replaceAll(".$", ""));
+        assertEquals("abc", StringHelper.removeLastCharRegex(WHITE_SPACE_AT_THE_END_STRING));
+        assertEquals("abc", StringHelper.removeLastCharOptional(WHITE_SPACE_AT_THE_END_STRING));
+        assertEquals("abc", StringHelper.removeLastCharRegexOptional(WHITE_SPACE_AT_THE_END_STRING));
+    }
+
+    @Test
+    public void givenStringWithNewLineAtTheEnd_whenSubstring_thenGetStringWithoutNewLine() {
+        assertEquals("abc", StringHelper.removeLastChar(NEW_LINE_AT_THE_END_STRING));
+        assertEquals("abc", StringUtils.substring(NEW_LINE_AT_THE_END_STRING, 0, NEW_LINE_AT_THE_END_STRING.length() - 1));
+        assertEquals("abc", StringUtils.chop(NEW_LINE_AT_THE_END_STRING));
+        assertNotEquals("abc", NEW_LINE_AT_THE_END_STRING.replaceAll(".$", ""));
+        assertNotEquals("abc", StringHelper.removeLastCharRegex(NEW_LINE_AT_THE_END_STRING));
+        assertEquals("abc", StringHelper.removeLastCharOptional(NEW_LINE_AT_THE_END_STRING));
+        assertNotEquals("abc", StringHelper.removeLastCharRegexOptional(NEW_LINE_AT_THE_END_STRING));
+    }
+
+    @Test
+    public void givenMultiLineString_whenSubstring_thenGetStringWithoutNewLine() {
+        assertEquals("abc\nde", StringHelper.removeLastChar(MULTIPLE_LINES_STRING));
+        assertEquals("abc\nde", StringUtils.substring(MULTIPLE_LINES_STRING, 0, MULTIPLE_LINES_STRING.length() - 1));
+        assertEquals("abc\nde", StringUtils.chop(MULTIPLE_LINES_STRING));
+        assertEquals("abc\nde", MULTIPLE_LINES_STRING.replaceAll(".$", ""));
+        assertEquals("abc\nde", StringHelper.removeLastCharRegex(MULTIPLE_LINES_STRING));
+        assertEquals("abc\nde", StringHelper.removeLastCharOptional(MULTIPLE_LINES_STRING));
+        assertEquals("abc\nde", StringHelper.removeLastCharRegexOptional(MULTIPLE_LINES_STRING));
+    }
+}

java-strings-ops/src/test/java/com/baeldung/string/SubstringUnitTest.java

@@ -0,0 +1,72 @@
+package com.baeldung.string;
+
+import java.util.Scanner;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SubstringUnitTest {
+
+    String text = "Julia Evans was born on 25-09-1984. She is currently living in the USA (United States of America).";
+
+    @Test
+    public void givenAString_whenUsedStringUtils_ShouldReturnProperSubstring() {
+        Assert.assertEquals("United States of America", StringUtils.substringBetween(text, "(", ")"));
+        Assert.assertEquals("the USA (United States of America).", StringUtils.substringAfter(text, "living in "));
+        Assert.assertEquals("Julia Evans", StringUtils.substringBefore(text, " was born"));
+    }
+
+    @Test
+    public void givenAString_whenUsedScanner_ShouldReturnProperSubstring() {
+        try (Scanner scanner = new Scanner(text)) {
+            scanner.useDelimiter("\\.");
+            Assert.assertEquals("Julia Evans was born on 25-09-1984", scanner.next());
+        }
+    }
+
+    @Test
+    public void givenAString_whenUsedSplit_ShouldReturnProperSubstring() {
+        String[] sentences = text.split("\\.");
+        Assert.assertEquals("Julia Evans was born on 25-09-1984", sentences[0]);
+    }
+
+    @Test
+    public void givenAString_whenUsedRegex_ShouldReturnProperSubstring() {
+        Pattern pattern = Pattern.compile("\\d{2}\\-\\d{2}-\\d{4}");
+        Matcher matcher = pattern.matcher(text);
+
+        if (matcher.find()) {
+            Assert.assertEquals("25-09-1984", matcher.group());
+        }
+    }
+
+    @Test
+    public void givenAString_whenUsedSubSequence_ShouldReturnProperSubstring() {
+        Assert.assertEquals("USA (United States of America)", text.subSequence(67, text.length() - 1));
+    }
+
+    @Test
+    public void givenAString_whenUsedSubstring_ShouldReturnProperSubstring() {
+        Assert.assertEquals("USA (United States of America).", text.substring(67));
+        Assert.assertEquals("USA (United States of America)", text.substring(67, text.length() - 1));
+    }
+
+    @Test
+    public void givenAString_whenUsedSubstringWithIndexOf_ShouldReturnProperSubstring() {
+        Assert.assertEquals("United States of America", text.substring(text.indexOf('(') + 1, text.indexOf(')')));
+    }
+
+    @Test
+    public void givenAString_whenUsedSubstringWithLastIndexOf_ShouldReturnProperSubstring() {
+        Assert.assertEquals("1984", text.substring(text.lastIndexOf('-') + 1, text.indexOf('.')));
+    }
+
+    @Test
+    public void givenAString_whenUsedSubstringWithIndexOfAString_ShouldReturnProperSubstring() {
+        Assert.assertEquals("USA (United States of America)", text.substring(text.indexOf("USA"), text.indexOf(')') + 1));
+    }
+
+}

java-strings-ops/src/test/java/com/baeldung/string/isnumeric/CoreJavaIsNumericUnitTest.java

@@ -0,0 +1,31 @@
+package com.baeldung.string.isnumeric;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+public class CoreJavaIsNumericUnitTest {
+    public static boolean isNumeric(String strNum) {
+        try {
+            double d = Double.parseDouble(strNum);
+        } catch (NumberFormatException | NullPointerException nfe) {
+            return false;
+        }
+        return true;
+    }
+
+    @Test
+    public void whenUsingCoreJava_thenTrue() {
+        // Valid Numbers
+        assertThat(isNumeric("22")).isTrue();
+        assertThat(isNumeric("5.05")).isTrue();
+        assertThat(isNumeric("-200")).isTrue();
+        assertThat(isNumeric("10.0d")).isTrue();
+        assertThat(isNumeric("   22   ")).isTrue();
+
+        // Invalid Numbers
+        assertThat(isNumeric(null)).isFalse();
+        assertThat(isNumeric("")).isFalse();
+        assertThat(isNumeric("abc")).isFalse();
+    }
+}

java-strings-ops/src/test/java/com/baeldung/string/isnumeric/NumberUtilsIsCreatableUnitTest.java

@@ -0,0 +1,28 @@
+package com.baeldung.string.isnumeric;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.apache.commons.lang3.math.NumberUtils;
+import org.junit.Test;
+
+public class NumberUtilsIsCreatableUnitTest {
+    @Test
+    public void givenApacheCommons_whenUsingIsParsable_thenTrue() {
+        // Valid Numbers
+        assertThat(NumberUtils.isCreatable("22")).isTrue();
+        assertThat(NumberUtils.isCreatable("5.05")).isTrue();
+        assertThat(NumberUtils.isCreatable("-200")).isTrue();
+        assertThat(NumberUtils.isCreatable("10.0d")).isTrue();
+        assertThat(NumberUtils.isCreatable("1000L")).isTrue();
+        assertThat(NumberUtils.isCreatable("0xFF")).isTrue();
+        assertThat(NumberUtils.isCreatable("07")).isTrue();
+        assertThat(NumberUtils.isCreatable("2.99e+8")).isTrue();
+
+        // Invalid Numbers
+        assertThat(NumberUtils.isCreatable(null)).isFalse();
+        assertThat(NumberUtils.isCreatable("")).isFalse();
+        assertThat(NumberUtils.isCreatable("abc")).isFalse();
+        assertThat(NumberUtils.isCreatable(" 22 ")).isFalse();
+        assertThat(NumberUtils.isCreatable("09")).isFalse();
+    }
+}

java-strings-ops/src/test/java/com/baeldung/string/isnumeric/NumberUtilsIsParsableUnitTest.java

@@ -0,0 +1,26 @@
+package com.baeldung.string.isnumeric;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.apache.commons.lang3.math.NumberUtils;
+import org.junit.Test;
+
+public class NumberUtilsIsParsableUnitTest {
+    @Test
+    public void givenApacheCommons_whenUsingIsParsable_thenTrue() {
+        // Valid Numbers
+        assertThat(NumberUtils.isParsable("22")).isTrue();
+        assertThat(NumberUtils.isParsable("-23")).isTrue();
+        assertThat(NumberUtils.isParsable("2.2")).isTrue();
+        assertThat(NumberUtils.isParsable("09")).isTrue();
+
+        // Invalid Numbers
+        assertThat(NumberUtils.isParsable(null)).isFalse();
+        assertThat(NumberUtils.isParsable("")).isFalse();
+        assertThat(NumberUtils.isParsable("6.2f")).isFalse();
+        assertThat(NumberUtils.isParsable("9.8d")).isFalse();
+        assertThat(NumberUtils.isParsable("22L")).isFalse();
+        assertThat(NumberUtils.isParsable("0xFF")).isFalse();
+        assertThat(NumberUtils.isParsable("2.99e+8")).isFalse();
+    }
+}

java-strings-ops/src/test/java/com/baeldung/string/isnumeric/RegularExpressionsUnitTest.java

@@ -0,0 +1,22 @@
+package com.baeldung.string.isnumeric;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+public class RegularExpressionsUnitTest {
+    public static boolean isNumeric(String strNum) {
+        return strNum.matches("-?\\d+(\\.\\d+)?");
+    }
+
+    @Test
+    public void whenUsingRegularExpressions_thenTrue() {
+        // Valid Numbers
+        assertThat(isNumeric("22")).isTrue();
+        assertThat(isNumeric("5.05")).isTrue();
+        assertThat(isNumeric("-200")).isTrue();
+
+        // Invalid Numbers
+        assertThat(isNumeric("abc")).isFalse();
+    }
+}

java-strings-ops/src/test/java/com/baeldung/string/isnumeric/StringUtilsIsNumericSpaceUnitTest.java

@@ -0,0 +1,24 @@
+package com.baeldung.string.isnumeric;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Test;
+
+public class StringUtilsIsNumericSpaceUnitTest {
+    @Test
+    public void givenApacheCommons_whenUsingIsNumericSpace_thenTrue() {
+        // Valid Numbers
+        assertThat(StringUtils.isNumericSpace("123")).isTrue();
+        assertThat(StringUtils.isNumericSpace("١٢٣")).isTrue();
+        assertThat(StringUtils.isNumericSpace("")).isTrue();
+        assertThat(StringUtils.isNumericSpace("  ")).isTrue();
+        assertThat(StringUtils.isNumericSpace("12 3")).isTrue();
+
+        // Invalid Numbers
+        assertThat(StringUtils.isNumericSpace(null)).isFalse();
+        assertThat(StringUtils.isNumericSpace("ab2c")).isFalse();
+        assertThat(StringUtils.isNumericSpace("12.3")).isFalse();
+        assertThat(StringUtils.isNumericSpace("-123")).isFalse();
+    }
+}

java-strings-ops/src/test/java/com/baeldung/string/isnumeric/StringUtilsIsNumericUnitTest.java

@@ -0,0 +1,25 @@
+package com.baeldung.string.isnumeric;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Test;
+
+public class StringUtilsIsNumericUnitTest {
+    @Test
+    public void givenApacheCommons_whenUsingIsNumeric_thenTrue() {
+        // Valid Numbers
+        assertThat(StringUtils.isNumeric("123")).isTrue();
+        assertThat(StringUtils.isNumeric("١٢٣")).isTrue();
+        assertThat(StringUtils.isNumeric("१२३")).isTrue();
+
+        // Invalid Numbers
+        assertThat(StringUtils.isNumeric(null)).isFalse();
+        assertThat(StringUtils.isNumeric("")).isFalse();
+        assertThat(StringUtils.isNumeric("  ")).isFalse();
+        assertThat(StringUtils.isNumeric("12 3")).isFalse();
+        assertThat(StringUtils.isNumeric("ab2c")).isFalse();
+        assertThat(StringUtils.isNumeric("12.3")).isFalse();
+        assertThat(StringUtils.isNumeric("-123")).isFalse();
+    }
+}

java-strings-ops/src/test/java/com/baeldung/string/tostring/CustomerArrayToStringUnitTest.java

@@ -0,0 +1,25 @@
+package com.baeldung.string.tostring;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+public class CustomerArrayToStringUnitTest {
+    private static final String CUSTOMER_ARRAY_TO_STRING = "Customer [orders=[Order [orderId=A1111, desc=Game, value=0]], getFirstName()=Rajesh, getLastName()=Bhojwani]";
+
+    @Test
+    public void givenArray_whenToString_thenCustomerDetails() {
+        CustomerArrayToString customer = new CustomerArrayToString();
+        customer.setFirstName("Rajesh");
+        customer.setLastName("Bhojwani");
+        Order[] orders = new Order[1];
+        orders[0] = new Order();
+        orders[0].setOrderId("A1111");
+        orders[0].setDesc("Game");
+        orders[0].setStatus("In-Shiping");
+        customer.setOrders(orders);
+
+        assertEquals(CUSTOMER_ARRAY_TO_STRING, customer.toString());
+    }
+
+}

java-strings-ops/src/test/java/com/baeldung/string/tostring/CustomerComplexObjectToStringUnitTest.java

@@ -0,0 +1,24 @@
+package com.baeldung.string.tostring;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+public class CustomerComplexObjectToStringUnitTest {
+    private static final String CUSTOMER_COMPLEX_TO_STRING = "Customer [order=Order [orderId=A1111, desc=Game, value=0], getFirstName()=Rajesh, getLastName()=Bhojwani]";
+
+    @Test
+    public void givenComplex_whenToString_thenCustomerDetails() {
+        CustomerComplexObjectToString customer = new CustomerComplexObjectToString();
+        customer.setFirstName("Rajesh");
+        customer.setLastName("Bhojwani");
+        Order order = new Order();
+        order.setOrderId("A1111");
+        order.setDesc("Game");
+        order.setStatus("In-Shiping");
+        customer.setOrder(order);
+
+        assertEquals(CUSTOMER_COMPLEX_TO_STRING, customer.toString());
+    }
+
+}

java-strings-ops/src/test/java/com/baeldung/string/tostring/CustomerPrimitiveToStringUnitTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.string.tostring;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+public class CustomerPrimitiveToStringUnitTest {
+
+    private static final String CUSTOMER_PRIMITIVE_TO_STRING = "Customer [balance=110, getFirstName()=Rajesh, getLastName()=Bhojwani]";
+
+    @Test
+    public void givenPrimitive_whenToString_thenCustomerDetails() {
+        CustomerPrimitiveToString customer = new CustomerPrimitiveToString();
+        customer.setFirstName("Rajesh");
+        customer.setLastName("Bhojwani");
+        customer.setBalance(110);
+
+        assertEquals(CUSTOMER_PRIMITIVE_TO_STRING, customer.toString());
+    }
+}

java-strings-ops/src/test/java/com/baeldung/string/tostring/CustomerWrapperCollectionToStringUnitTest.java

@@ -0,0 +1,32 @@
+package com.baeldung.string.tostring;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+public class CustomerWrapperCollectionToStringUnitTest {
+    private static final String CUSTOMER_WRAPPER_COLLECTION_TO_STRING = "Customer [score=8, orders=[Book, Pen], fullname=Bhojwani, Rajesh, getFirstName()=Rajesh, getLastName()=Bhojwani]";
+
+    @Test
+    public void givenWrapperCollectionStrBuffer_whenToString_thenCustomerDetails() {
+        CustomerWrapperCollectionToString customer = new CustomerWrapperCollectionToString();
+        customer.setFirstName("Rajesh");
+        customer.setLastName("Bhojwani");
+        customer.setScore(8);
+
+        List<String> orders = new ArrayList<String>();
+        orders.add("Book");
+        orders.add("Pen");
+        customer.setOrders(orders);
+
+        StringBuffer fullname = new StringBuffer();
+        fullname.append(customer.getLastName() + ", " + customer.getFirstName());
+        customer.setFullname(fullname);
+
+        assertEquals(CUSTOMER_WRAPPER_COLLECTION_TO_STRING, customer.toString());
+    }
+
+}

java-strings-ops/src/test/java/com/baeldung/stringpool/StringPoolUnitTest.java

@@ -0,0 +1,44 @@
+package com.baeldung.stringpool;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+public class StringPoolUnitTest {
+
+    @Test
+    public void whenCreatingConstantStrings_thenTheirAddressesAreEqual() {
+        String constantString1 = "Baeldung";
+        String constantString2 = "Baeldung";
+
+        assertThat(constantString1).isSameAs(constantString2);
+    }
+
+    @Test
+    public void whenCreatingStringsWithTheNewOperator_thenTheirAddressesAreDifferent() {
+        String newString1 = new String("Baeldung");
+        String newString2 = new String("Baeldung");
+
+        assertThat(newString1).isNotSameAs(newString2);
+    }
+
+    @Test
+    public void whenComparingConstantAndNewStrings_thenTheirAddressesAreDifferent() {
+        String constantString = "Baeldung";
+        String newString = new String("Baeldung");
+
+        assertThat(constantString).isNotSameAs(newString);
+    }
+
+    @Test
+    public void whenInterningAStringWithIdenticalValueToAnother_thenTheirAddressesAreEqual() {
+        String constantString = "interned Baeldung";
+        String newString = new String("interned Baeldung");
+
+        assertThat(constantString).isNotSameAs(newString);
+
+        String internedString = newString.intern();
+
+        assertThat(constantString).isSameAs(internedString);
+    }
+}