Update README.md

java-strings/src/test/java/com/baeldung/CharArrayToStringUnitTest.java

@@ -0,0 +1,62 @@
+package com.baeldung;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class CharArrayToStringUnitTest {
+
+    @Test
+    public void givenCharArray_whenCallingStringConstructor_shouldConvertToString() {
+        char[] charArray = { 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r' };
+        String result = new String(charArray);
+        String expectedValue = "character";
+
+        assertEquals(expectedValue, result);
+    }
+
+    @Test
+    public void givenCharArray_whenCallingStringConstructorWithOffsetAndLength_shouldConvertToString() {
+        char[] charArray = { 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r' };
+        String result = new String(charArray, 4, 3);
+        String expectedValue = "act";
+
+        assertEquals(expectedValue, result);
+    }
+
+    @Test
+    public void givenCharArray_whenCallingStringCopyValueOf_shouldConvertToString() {
+        char[] charArray = { 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r' };
+        String result = String.copyValueOf(charArray);
+        String expectedValue = "character";
+
+        assertEquals(expectedValue, result);
+    }
+
+    @Test
+    public void givenCharArray_whenCallingStringCopyValueOfWithOffsetAndLength_shouldConvertToString() {
+        char[] charArray = { 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r' };
+        String result = String.copyValueOf(charArray, 0, 4);
+        String expectedValue = "char";
+
+        assertEquals(expectedValue, result);
+    }
+
+    @Test
+    public void givenCharArray_whenCallingStringValueOf_shouldConvertToString() {
+        char[] charArray = { 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r' };
+        String result = String.valueOf(charArray);
+        String expectedValue = "character";
+
+        assertEquals(expectedValue, result);
+    }
+
+    @Test
+    public void givenCharArray_whenCallingStringValueOfWithOffsetAndLength_shouldConvertToString() {
+        char[] charArray = { 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r' };
+        String result = String.valueOf(charArray, 3, 4);
+        String expectedValue = "ract";
+
+        assertEquals(expectedValue, result);
+    }
+}

java-strings/src/test/java/com/baeldung/StringToCharArrayUnitTest.java

@@ -0,0 +1,20 @@
+package com.baeldung;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class StringToCharArrayUnitTest {
+
+    @Test
+    public void givenString_whenCallingStringToCharArray_shouldConvertToCharArray() {
+        String givenString = "characters";
+
+        char[] result = givenString.toCharArray();
+
+        char[] expectedCharArray = { 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's' };
+
+        assertArrayEquals(expectedCharArray, result);
+    }
+
+}

java-strings/src/test/java/com/baeldung/StringToIntOrIntegerUnitTest.java

@@ -0,0 +1,62 @@
+package com.baeldung;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+import com.google.common.primitives.Ints;
+
+public class StringToIntOrIntegerUnitTest {
+
+    @Test
+    public void givenString_whenParsingInt_shouldConvertToInt() {
+        String givenString = "42";
+
+        int result = Integer.parseInt(givenString);
+
+        assertThat(result).isEqualTo(42);
+    }
+
+    @Test
+    public void givenString_whenCallingIntegerValueOf_shouldConvertToInt() {
+        String givenString = "42";
+
+        Integer result = Integer.valueOf(givenString);
+
+        assertThat(result).isEqualTo(new Integer(42));
+    }
+
+    @Test
+    public void givenString_whenCallingIntegerConstructor_shouldConvertToInt() {
+        String givenString = "42";
+
+        Integer result = new Integer(givenString);
+
+        assertThat(result).isEqualTo(new Integer(42));
+    }
+
+    @Test
+    public void givenString_whenCallingIntegerDecode_shouldConvertToInt() {
+        String givenString = "42";
+
+        int result = Integer.decode(givenString);
+
+        assertThat(result).isEqualTo(42);
+    }
+
+    @Test
+    public void givenString_whenTryParse_shouldConvertToInt() {
+        String givenString = "42";
+
+        Integer result = Ints.tryParse(givenString);
+
+        assertThat(result).isEqualTo(42);
+    }
+
+    @Test(expected = NumberFormatException.class)
+    public void givenInvalidInput_whenParsingInt_shouldThrow() {
+        String givenString = "nan";
+        Integer.parseInt(givenString);
+    }
+
+}

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");
+	}
+}

java-strings/src/test/java/com/baeldung/enums/PizzaUnitTest.java

@@ -0,0 +1,27 @@
+package com.baeldung.enums;
+
+import static junit.framework.TestCase.assertTrue;
+
+import org.junit.Test;
+
+public class PizzaUnitTest {
+    
+    @Test
+    public void whenConvertedIntoEnum_thenGetsConvertedCorrectly() {
+        String pizzaEnumValue = "READY";
+        PizzaStatusEnum pizzaStatusEnum = PizzaStatusEnum.valueOf(pizzaEnumValue);
+        assertTrue(pizzaStatusEnum == PizzaStatusEnum.READY);
+    }
+    
+    @Test(expected = IllegalArgumentException.class)
+    public void whenConvertedIntoEnum_thenThrowsException() {
+        String pizzaEnumValue = "rEAdY";
+        PizzaStatusEnum pizzaStatusEnum = PizzaStatusEnum.valueOf(pizzaEnumValue);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void givenInvalidEnumValueContentWiseAsString_whenConvertedIntoEnum_thenThrowsException() {
+        String pizzaEnumValue = "invalid";
+        PizzaStatusEnum pizzaStatusEnum = PizzaStatusEnum.valueOf(pizzaEnumValue);
+    }
+}

java-strings/src/test/java/com/baeldung/string/JoinerSplitterUnitTest.java

@@ -0,0 +1,83 @@
+package com.baeldung.string;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+
+public class JoinerSplitterUnitTest {
+
+    @Test
+    public void provided_array_convert_to_stream_and_convert_to_string() {
+
+        String[] programming_languages = {"java", "python", "nodejs", "ruby"};
+
+        String expectation = "java,python,nodejs,ruby";
+
+        String result = JoinerSplitter.join(programming_languages);
+        assertEquals(result, expectation);
+    }
+
+    @Test
+    public void givenArray_transformedToStream_convertToPrefixPostfixString() {
+
+        String[] programming_languages = {"java", "python",
+          "nodejs", "ruby"};
+        String expectation = "[java,python,nodejs,ruby]";
+
+        String result = JoinerSplitter.joinWithPrefixPostFix(programming_languages);
+        assertEquals(result, expectation);
+    }
+
+    @Test
+    public void givenString_transformedToStream_convertToList() {
+
+        String programming_languages = "java,python,nodejs,ruby";
+
+        List<String> expectation = new ArrayList<String>();
+        expectation.add("java");
+        expectation.add("python");
+        expectation.add("nodejs");
+        expectation.add("ruby");
+
+        List<String> result = JoinerSplitter.split(programming_languages);
+
+        assertEquals(result, expectation);
+    }
+
+    @Test
+    public void givenString_transformedToStream_convertToListOfChar() {
+
+        String programming_languages = "java,python,nodejs,ruby";
+
+        List<Character> expectation = new ArrayList<Character>();
+        char[] charArray = programming_languages.toCharArray();
+        for (char c : charArray) {
+            expectation.add(c);
+        }
+
+        List<Character> result = JoinerSplitter.splitToListOfChar(programming_languages);
+        assertEquals(result, expectation);
+
+    }
+    
+    @Test
+    public void givenStringArray_transformedToStream_convertToMap() {
+
+        String[] programming_languages = new String[] {"language:java","os:linux","editor:emacs"};
+        
+        Map<String,String> expectation=new HashMap<>();
+        expectation.put("language", "java");
+        expectation.put("os", "linux");
+        expectation.put("editor", "emacs");
+        
+        Map<String, String> result = JoinerSplitter.arrayToMap(programming_languages);
+        assertEquals(result, expectation);
+        
+    }
+
+}

java-strings/src/test/java/com/baeldung/string/ReplaceCharInStringUnitTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.string;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class ReplaceCharInStringUnitTest {
+    private ReplaceCharacterInString characterInString = new ReplaceCharacterInString();
+
+    @Test
+    public void whenReplaceCharAtIndexUsingSubstring_thenSuccess() {
+        assertEquals("abcme", characterInString.replaceCharSubstring("abcde", 'm', 3));
+    }
+
+    @Test
+    public void whenReplaceCharAtIndexUsingCharArray_thenSuccess() {
+        assertEquals("abcme", characterInString.replaceCharUsingCharArray("abcde", 'm', 3));
+    }
+
+    @Test
+    public void whenReplaceCharAtIndexUsingStringBuilder_thenSuccess() {
+        assertEquals("abcme", characterInString.replaceCharStringBuilder("abcde", 'm', 3));
+    }
+
+    @Test
+    public void whenReplaceCharAtIndexUsingStringBuffer_thenSuccess() {
+        assertEquals("abcme", characterInString.replaceCharStringBuffer("abcde", 'm', 3));
+    }
+}

java-strings/src/test/java/com/baeldung/string/StringContainingCharactersUnitTest.java

@@ -0,0 +1,136 @@
+package com.baeldung.string;
+
+import org.junit.Test;
+
+import java.util.regex.Pattern;
+
+import static junit.framework.TestCase.assertFalse;
+import static junit.framework.TestCase.assertTrue;
+
+public class StringContainingCharactersUnitTest {
+
+    private static final Pattern[] inputRegexes = new Pattern[4];
+
+    private static final String regex = "^(?=.*?\\p{Lu})(?=.*?\\p{Ll})(?=.*?\\d)(?=.*?[`~!@#$%^&*()\\-_=+\\\\|\\[{\\]};:'\",<.>/?]).*$";
+
+    static {
+        inputRegexes[0] = Pattern.compile(".*[A-Z].*");
+        inputRegexes[1] = Pattern.compile(".*[a-z].*");
+        inputRegexes[2] = Pattern.compile(".*\\d.*");
+        inputRegexes[3] = Pattern.compile(".*[`~!@#$%^&*()\\-_=+\\\\|\\[{\\]};:'\",<.>/?].*");
+    }
+
+    private static boolean isMatchingRegex(String input) {
+        boolean inputMatches = true;
+        for (Pattern inputRegex : inputRegexes) {
+            if (!inputRegex
+              .matcher(input)
+              .matches()) {
+                inputMatches = false;
+            }
+        }
+        return inputMatches;
+    }
+
+    private static boolean checkString(String input) {
+        String specialChars = "~`!@#$%^&*()-_=+\\|[{]};:'\",<.>/?";
+        char currentCharacter;
+        boolean numberPresent = false;
+        boolean upperCasePresent = false;
+        boolean lowerCasePresent = false;
+        boolean specialCharacterPresent = false;
+
+        for (int i = 0; i < input.length(); i++) {
+            currentCharacter = input.charAt(i);
+            if (Character.isDigit(currentCharacter)) {
+                numberPresent = true;
+            } else if (Character.isUpperCase(currentCharacter)) {
+                upperCasePresent = true;
+            } else if (Character.isLowerCase(currentCharacter)) {
+                lowerCasePresent = true;
+            } else if (specialChars.contains(String.valueOf(currentCharacter))) {
+                specialCharacterPresent = true;
+            }
+        }
+
+        return numberPresent && upperCasePresent && lowerCasePresent && specialCharacterPresent;
+    }
+
+    @Test
+    public void givenRegexes_whenMatchingCorrectString_thenMatches() {
+        String validInput = "Ab3;";
+        assertTrue(isMatchingRegex(validInput));
+    }
+
+    @Test
+    public void givenRegexes_whenMatchingWrongStrings_thenNotMatching() {
+        String invalidInput = "Ab3";
+        assertFalse(isMatchingRegex(invalidInput));
+
+        invalidInput = "Ab;";
+        assertFalse(isMatchingRegex(invalidInput));
+
+        invalidInput = "A3;";
+        assertFalse(isMatchingRegex(invalidInput));
+
+        invalidInput = "b3;";
+        assertFalse(isMatchingRegex(invalidInput));
+    }
+
+    @Test
+    public void givenValidString_whenChecking_thenCorrect() {
+        String validInput = "Ab3;";
+        assertTrue(checkString(validInput));
+    }
+
+    @Test
+    public void givenInvalidStrings_whenChecking_thenNotCorrect() {
+        String invalidInput = "Ab3";
+        assertFalse(checkString(invalidInput));
+
+        invalidInput = "Ab;";
+        assertFalse(checkString(invalidInput));
+
+        invalidInput = "A3;";
+        assertFalse(checkString(invalidInput));
+
+        invalidInput = "b3;";
+        assertFalse(checkString(invalidInput));
+    }
+
+    @Test
+    public void givenSingleRegex_whenMatchingCorrectString_thenMatches() {
+        String validInput = "Ab3;";
+        assertTrue(Pattern
+          .compile(regex)
+          .matcher(validInput)
+          .matches());
+    }
+
+    @Test
+    public void givenSingleRegex_whenMatchingWrongStrings_thenNotMatching() {
+        String invalidInput = "Ab3";
+        assertFalse(Pattern
+          .compile(regex)
+          .matcher(invalidInput)
+          .matches());
+
+        invalidInput = "Ab;";
+        assertFalse(Pattern
+          .compile(regex)
+          .matcher(invalidInput)
+          .matches());
+
+        invalidInput = "A3;";
+        assertFalse(Pattern
+          .compile(regex)
+          .matcher(invalidInput)
+          .matches());
+
+        invalidInput = "b3;";
+        assertFalse(Pattern
+          .compile(regex)
+          .matcher(invalidInput)
+          .matches());
+    }
+}

java-strings/src/test/java/com/baeldung/string/StringEmptyUnitTest.java

@@ -0,0 +1,51 @@
+package com.baeldung.string;
+
+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.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import org.apache.commons.lang3.StringUtils;
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+
+import com.google.common.base.Strings;
+
+public class StringEmptyUnitTest {
+
+    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));
+    }
+
+}

java-strings/src/test/java/com/baeldung/string/StringReplaceAndRemoveUnitTest.java

@@ -0,0 +1,90 @@
+package com.baeldung.string;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.RegExUtils;
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class StringReplaceAndRemoveUnitTest {
+
+    @Test
+    public void givenTestStrings_whenReplace_thenProcessedString() {
+
+        String master = "Hello World Baeldung!";
+        String target = "Baeldung";
+        String replacement = "Java";
+        String processed = master.replace(target, replacement);
+        assertTrue(processed.contains(replacement));
+        assertFalse(processed.contains(target));
+
+    }
+
+    @Test
+    public void givenTestStrings_whenReplaceAll_thenProcessedString() {
+
+        String master2 = "Welcome to Baeldung, Hello World Baeldung";
+        String regexTarget = "(Baeldung)$";
+        String replacement = "Java";
+        String processed2 = master2.replaceAll(regexTarget, replacement);
+        assertTrue(processed2.endsWith("Java"));
+
+    }
+
+    @Test
+    public void givenTestStrings_whenStringBuilderMethods_thenProcessedString() {
+
+        String master = "Hello World Baeldung!";
+        String target = "Baeldung";
+        String replacement = "Java";
+
+        int startIndex = master.indexOf(target);
+        int stopIndex = startIndex + target.length();
+
+        StringBuilder builder = new StringBuilder(master);
+
+        builder.delete(startIndex, stopIndex);
+        assertFalse(builder.toString()
+            .contains(target));
+
+        builder.replace(startIndex, stopIndex, replacement);
+        assertTrue(builder.toString()
+            .contains(replacement));
+
+    }
+
+    @Test
+    public void givenTestStrings_whenStringUtilsMethods_thenProcessedStrings() {
+
+        String master = "Hello World Baeldung!";
+        String target = "Baeldung";
+        String replacement = "Java";
+
+        String processed = StringUtils.replace(master, target, replacement);
+        assertTrue(processed.contains(replacement));
+
+        String master2 = "Hello World Baeldung!";
+        String target2 = "baeldung";
+        String processed2 = StringUtils.replaceIgnoreCase(master2, target2, replacement);
+        assertFalse(processed2.contains(target));
+
+    }
+
+    @Test
+    public void givenTestStrings_whenReplaceExactWord_thenProcessedString() {
+        String sentence = "A car is not the same as a carriage, and some planes can carry cars inside them!";
+        String regexTarget = "\\bcar\\b";
+        String exactWordReplaced = sentence.replaceAll(regexTarget, "truck");
+        assertTrue("A truck is not the same as a carriage, and some planes can carry cars inside them!".equals(exactWordReplaced));
+    }
+
+    @Test
+    public void givenTestStrings_whenReplaceExactWordUsingRegExUtilsMethod_thenProcessedString() {
+        String sentence = "A car is not the same as a carriage, and some planes can carry cars inside them!";
+        String regexTarget = "\\bcar\\b";
+        String exactWordReplaced = RegExUtils.replaceAll(sentence, regexTarget, "truck");
+        assertTrue("A truck is not the same as a carriage, and some planes can carry cars inside them!".equals(exactWordReplaced));
+    }
+
+}

java-strings/src/test/java/com/baeldung/string/StringToCharStreamUnitTest.java

@@ -0,0 +1,59 @@
+package com.baeldung.string;
+
+import org.junit.Test;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThat;
+
+public class StringToCharStreamUnitTest {
+
+    private String testString = "Tests";
+
+    @Test
+    public void givenTestString_whenChars_thenReturnIntStream() {
+        assertThat(testString.chars(), instanceOf(IntStream.class));
+    }
+
+    @Test
+    public void givenTestString_whenCodePoints_thenReturnIntStream() {
+        assertThat(testString.codePoints(), instanceOf(IntStream.class));
+    }
+
+    @Test
+    public void givenTestString_whenCodePoints_thenShowOccurences() throws Exception {
+        Map<Character, Integer> map = testString.codePoints()
+          .mapToObj(c -> (char) c)
+          .filter(Character::isLetter)
+          .collect(Collectors.toMap(c -> c, c -> 1, Integer::sum));
+
+        System.out.println(map);
+    }
+
+    @Test
+    public void givenIntStream_whenMapToObj_thenReturnCharacterStream() {
+        Stream<Character> characterStream = testString.chars()
+          .mapToObj(c -> (char) c);
+        Stream<Character> characterStream1 = testString.codePoints()
+          .mapToObj(c -> (char) c);
+        assertNotNull("IntStream returned by chars() did not map to Stream<Character>", characterStream);
+        assertNotNull("IntStream returned by codePoints() did not map to Stream<Character>", characterStream1);
+    }
+
+    @Test
+    public void givenIntStream_whenMapToObj_thenReturnStringStream() {
+        List<String> strings = testString.codePoints()
+          .mapToObj(c -> String.valueOf((char) c))
+          .collect(Collectors.toList());
+
+        assertEquals(strings.size(), 5);
+    }
+
+}

java-strings/src/test/java/com/baeldung/string/StringUnitTest.java

@@ -0,0 +1,226 @@
+package com.baeldung.string;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.StandardCharsets;
+import java.util.IllegalFormatException;
+import java.util.regex.PatternSyntaxException;
+
+import org.junit.Test;
+
+public class StringUnitTest {
+
+    @Test
+    public void whenCallCodePointAt_thenDecimalUnicodeReturned() {
+        assertEquals(97, "abcd".codePointAt(0));
+    }
+
+    @Test(expected = StringIndexOutOfBoundsException.class)
+    public void whenPassNonExistingIndex_thenExceptionThrown() {
+        int a = "abcd".codePointAt(4);
+    }
+
+    @Test
+    public void whenCallConcat_thenCorrect() {
+        assertEquals("elephant", "elep".concat("hant"));
+    }
+
+    @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);
+    }
+
+    @Test
+    public void whenGetBytesUsingASCII_thenCorrect() {
+        byte[] byteArray = "efgh".getBytes(StandardCharsets.US_ASCII);
+        byte[] expected = new byte[] { 101, 102, 103, 104 };
+
+        assertArrayEquals(expected, byteArray);
+    }
+
+    @Test
+    public void whenCreateStringUsingByteArray_thenCorrect() {
+        byte[] array = new byte[] { 97, 98, 99, 100 };
+        String s = new String(array);
+
+        assertEquals("abcd", s);
+    }
+
+    @Test
+    public void whenCallCharAt_thenCorrect() {
+        assertEquals('P', "Paul".charAt(0));
+    }
+
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void whenCharAtOnNonExistingIndex_thenIndexOutOfBoundsExceptionThrown() {
+        char character = "Paul".charAt(4);
+    }
+
+    @Test
+    public void whenCallCodePointCount_thenCorrect() {
+        assertEquals(2, "abcd".codePointCount(0, 2));
+    }
+
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void whenSecondIndexEqualToLengthOfString_thenIndexOutOfBoundsExceptionThrown() {
+        char character = "Paul".charAt(4);
+    }
+
+    @Test
+    public void whenCallContains_thenCorrect() {
+        String s = "abcd";
+
+        assertTrue(s.contains("abc"));
+        assertFalse(s.contains("cde"));
+    }
+
+    @Test
+    public void whenCallCopyValueOf_thenStringConstructed() {
+        char[] array = new char[] { 'a', 'b', 'c', 'd' };
+
+        assertEquals("abcd", String.copyValueOf(array));
+    }
+
+    @Test
+    public void whenCallEndsWith_thenCorrect() {
+        String s1 = "test";
+
+        assertTrue(s1.endsWith("t"));
+    }
+
+    @Test
+    public void whenFormat_thenCorrect() {
+        String value = "Baeldung";
+        String formatted = String.format("Welcome to %s!", value);
+
+        assertEquals("Welcome to Baeldung!", formatted);
+    }
+
+    @Test(expected = IllegalFormatException.class)
+    public void whenInvalidFormatSyntax_thenIllegalFormatExceptionThrown() {
+        String value = "Baeldung";
+        String formatted = String.format("Welcome to %x!", value);
+    }
+
+    @Test
+    public void whenCallIndexOf_thenCorrect() {
+        assertEquals(1, "foo".indexOf("o"));
+    }
+
+    @Test
+    public void whenCallIsEmpty_thenCorrect() {
+        String s1 = "";
+
+        assertTrue(s1.isEmpty());
+    }
+
+    @Test
+    public void whenCallLastIndexOf_thenCorrect() {
+        assertEquals(2, "foo".lastIndexOf("o"));
+        assertEquals(2, "foo".lastIndexOf(111));
+    }
+
+    @Test
+    public void whenCallRegionMatches_thenCorrect() {
+        assertTrue("welcome to baeldung".regionMatches(false, 11, "baeldung", 0, 8));
+    }
+
+    @Test
+    public void whenCallStartsWith_thenCorrect() {
+        assertTrue("foo".startsWith("f"));
+    }
+
+    @Test
+    public void whenTrim_thenCorrect() {
+        assertEquals("foo", " foo  ".trim());
+    }
+
+    @Test
+    public void whenSplit_thenCorrect() {
+        String s = "Welcome to Baeldung";
+        String[] array = new String[] { "Welcome", "to", "Baeldung" };
+
+        assertArrayEquals(array, s.split(" "));
+    }
+
+    @Test(expected = PatternSyntaxException.class)
+    public void whenPassInvalidParameterToSplit_thenPatternSyntaxExceptionThrown() {
+        String s = "Welcome*to Baeldung";
+
+        String[] result = s.split("*");
+    }
+
+    @Test
+    public void whenCallSubSequence_thenCorrect() {
+        String s = "Welcome to Baeldung";
+
+        assertEquals("Welcome", s.subSequence(0, 7));
+    }
+
+    @Test
+    public void whenCallSubstring_thenCorrect() {
+        String s = "Welcome to Baeldung";
+
+        assertEquals("Welcome", s.substring(0, 7));
+    }
+
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void whenSecondIndexEqualToLengthOfString_thenCorrect() {
+        String s = "Welcome to Baeldung";
+
+        String sub = s.substring(0, 20);
+    }
+
+    @Test
+    public void whenConvertToUpperCase_thenCorrect() {
+        String s = "Welcome to Baeldung!";
+
+        assertEquals("WELCOME TO BAELDUNG!", s.toUpperCase());
+    }
+
+    @Test
+    public void whenConvertToLowerCase_thenCorrect() {
+        String s = "WELCOME to BAELDUNG!";
+
+        assertEquals("welcome to baeldung!", s.toLowerCase());
+    }
+
+    @Test
+    public void whenCallReplace_thenCorrect() {
+        String s = "I learn Spanish";
+
+        assertEquals("I learn French", s.replaceAll("Spanish", "French"));
+    }
+
+    @Test
+    public void whenIntern_thenCorrect() {
+        String s1 = "abc";
+        String s2 = new String("abc");
+        String s3 = new String("foo");
+        String s4 = s1.intern();
+        String s5 = s2.intern();
+
+        assertFalse(s3 == s4);
+        assertTrue(s1 == s5);
+    }
+
+    @Test
+    public void whenCallValueOf_thenCorrect() {
+        long l = 200L;
+
+        assertEquals("200", String.valueOf(l));
+    }
+}

java-strings/src/test/java/com/baeldung/string/TitleCaseConverterUnitTest.java

@@ -0,0 +1,70 @@
+package com.baeldung.string;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class TitleCaseConverterUnitTest {
+
+    private static final String TEXT = "tHis IS a tiTLe";
+    private static final String TEXT_EXPECTED = "This Is A Title";
+    private static final String TEXT_EXPECTED_NOT_FULL = "THis IS A TiTLe";
+
+    private static final String TEXT_OTHER_DELIMITERS = "tHis, IS a   tiTLe";
+    private static final String TEXT_EXPECTED_OTHER_DELIMITERS = "This, Is A   Title";
+    private static final String TEXT_EXPECTED_OTHER_DELIMITERS_NOT_FULL = "THis, IS A   TiTLe";
+
+    @Test
+    public void whenConvertingToTitleCaseIterating_thenStringConverted() {
+        assertEquals(TEXT_EXPECTED, TitleCaseConverter.convertToTitleCaseIteratingChars(TEXT));
+    }
+
+    @Test
+    public void whenConvertingToTitleCaseSplitting_thenStringConverted() {
+        assertEquals(TEXT_EXPECTED, TitleCaseConverter.convertToTitleCaseSplitting(TEXT));
+    }
+
+    @Test
+    public void whenConvertingToTitleCaseUsingWordUtilsFull_thenStringConverted() {
+        assertEquals(TEXT_EXPECTED, TitleCaseConverter.convertToTileCaseWordUtilsFull(TEXT));
+    }
+
+    @Test
+    public void whenConvertingToTitleCaseUsingWordUtils_thenStringConvertedOnlyFirstCharacter() {
+        assertEquals(TEXT_EXPECTED_NOT_FULL, TitleCaseConverter.convertToTileCaseWordUtils(TEXT));
+    }
+
+    @Test
+    public void whenConvertingToTitleCaseUsingIcu4j_thenStringConverted() {
+        assertEquals(TEXT_EXPECTED, TitleCaseConverter.convertToTitleCaseIcu4j(TEXT));
+    }
+
+    @Test
+    public void whenConvertingToTitleCaseWithDifferentDelimiters_thenDelimitersKept() {
+        assertEquals(TEXT_EXPECTED_OTHER_DELIMITERS, TitleCaseConverter.convertToTitleCaseIteratingChars(TEXT_OTHER_DELIMITERS));
+        assertEquals(TEXT_EXPECTED_OTHER_DELIMITERS, TitleCaseConverter.convertToTitleCaseSplitting(TEXT_OTHER_DELIMITERS));
+        assertEquals(TEXT_EXPECTED_OTHER_DELIMITERS, TitleCaseConverter.convertToTileCaseWordUtilsFull(TEXT_OTHER_DELIMITERS));
+        assertEquals(TEXT_EXPECTED_OTHER_DELIMITERS_NOT_FULL, TitleCaseConverter.convertToTileCaseWordUtils(TEXT_OTHER_DELIMITERS));
+        assertEquals(TEXT_EXPECTED_OTHER_DELIMITERS, TitleCaseConverter.convertToTitleCaseIcu4j(TEXT_OTHER_DELIMITERS));
+    }
+
+    @Test
+    public void givenNull_whenConvertingToTileCase_thenReturnNull() {
+        assertEquals(null, TitleCaseConverter.convertToTitleCaseIteratingChars(null));
+        assertEquals(null, TitleCaseConverter.convertToTitleCaseSplitting(null));
+        assertEquals(null, TitleCaseConverter.convertToTileCaseWordUtilsFull(null));
+        assertEquals(null, TitleCaseConverter.convertToTileCaseWordUtils(null));
+        assertEquals(null, TitleCaseConverter.convertToTitleCaseIcu4j(null));
+    }
+
+    @Test
+    public void givenEmptyString_whenConvertingToTileCase_thenReturnEmptyString() {
+        assertEquals("", TitleCaseConverter.convertToTitleCaseIteratingChars(""));
+        assertEquals("", TitleCaseConverter.convertToTitleCaseSplitting(""));
+        assertEquals("", TitleCaseConverter.convertToTileCaseWordUtilsFull(""));
+        assertEquals("", TitleCaseConverter.convertToTileCaseWordUtils(""));
+        assertEquals("", TitleCaseConverter.convertToTitleCaseIcu4j(""));
+    }
+
+}

java-strings/src/test/java/com/baeldung/string/searching/WordIndexerUnitTest.java

@@ -0,0 +1,62 @@
+package com.baeldung.string.searching;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+
+public class WordIndexerUnitTest {
+
+    String theString;
+    WordIndexer wordIndexer;
+
+    @BeforeEach
+    public void setUp() throws Exception {
+        wordIndexer = new WordIndexer();
+
+        theString = "To be, or not to be: that is the question: "
+          + "Whether 'tis nobler in the mind to suffer "
+          + "The slings and arrows of outrageous fortune, "
+          + "Or to take arms against a sea of troubles, "
+          + "And by opposing end them? To die: to sleep; "
+          + "No more; and by a sleep to say we end "
+          + "The heart-ache and the thousand natural shocks "
+          + "That flesh is heir to, 'tis a consummation "
+          + "Devoutly to be wish'd. To die, to sleep; "
+          + "To sleep: perchance to dream: ay, there's the rub: "
+          + "For in that sleep of death what dreams may come,";
+    }
+
+    @Test
+
+    public void givenWord_whenSearching_thenFindAllIndexedLocations() {
+        List<Integer> expectedResult = Arrays.asList(7, 122, 130, 221, 438);
+
+        List<Integer> actualResult = wordIndexer.findWord(theString, "or");
+
+        assertEquals(expectedResult, actualResult);
+    }
+
+    @Test
+    public void givenWordWithNoRepeatCharacters_whenImprovedSearching_thenFindAllIndexedLocations() {
+        List<Integer> expectedResult = Arrays.asList(7, 122, 130, 221, 438);
+
+        List<Integer> actualResult = wordIndexer.findWordUpgrade(theString, "or");
+
+        assertEquals(expectedResult, actualResult);
+    }
+
+
+    @Test
+    public void givenWord_whenSearching_thenFindAtEndOfString() {
+        List<Integer> expectedResult = Arrays.asList(480);
+
+        List<Integer> actualResult = wordIndexer.findWordUpgrade(theString, "come,");
+
+        assertEquals(expectedResult, actualResult);
+    }
+}

java-strings/src/test/java/com/baeldung/string/sorting/AnagramValidatorUnitTest.java

@@ -0,0 +1,26 @@
+package com.baeldung.string.sorting;
+
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import org.junit.jupiter.api.Test;
+
+import com.baeldung.string.sorting.AnagramValidator;
+
+class AnagramValidatorUnitTest {
+    
+    @Test
+    void givenValidAnagrams_whenSorted_thenEqual() {
+        boolean isValidAnagram = AnagramValidator.isValid("Avida Dollars", "Salvador Dali");
+        
+        assertTrue(isValidAnagram);
+    }
+    
+    @Test
+    void givenNotValidAnagrams_whenSorted_thenNotEqual() {
+        boolean isValidAnagram = AnagramValidator.isValid("abc", "def");
+        
+        assertFalse(isValidAnagram);
+    }
+}

java-strings/src/test/java/com/baeldung/string/sorting/SortStringUnitTest.java

@@ -0,0 +1,31 @@
+package com.baeldung.string.sorting;
+
+import java.util.Arrays;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class SortStringUnitTest {
+
+    @Test
+    void givenString_whenSort_thenSorted() {
+        String abcd = "bdca";
+        char[] chars = abcd.toCharArray();
+
+        Arrays.sort(chars);
+        String sorted = new String(chars);
+
+        assertThat(sorted).isEqualTo("abcd");
+    }
+
+    @Test
+    void givenString_whenSortJava8_thenSorted() {
+        String sorted = "bdca".chars()
+            .sorted()
+            .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
+            .toString();
+
+        assertThat(sorted).isEqualTo("abcd");
+    }
+}

java-strings/src/test/java/com/baeldung/stringisnumeric/NumberUtilsIsCreatableUnitTest.java

@@ -0,0 +1,28 @@
+package com.baeldung.stringisnumeric;
+
+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/src/test/java/com/baeldung/stringisnumeric/NumberUtilsIsParsableUnitTest.java

@@ -0,0 +1,26 @@
+package com.baeldung.stringisnumeric;
+
+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/src/test/java/com/baeldung/stringisnumeric/RegularExpressionsUnitTest.java

@@ -0,0 +1,22 @@
+package com.baeldung.stringisnumeric;
+
+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/src/test/java/com/baeldung/stringisnumeric/StringUtilsIsNumericSpaceUnitTest.java

@@ -0,0 +1,23 @@
+package com.baeldung.stringisnumeric;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+
+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/src/test/java/com/baeldung/stringisnumeric/StringUtilsIsNumericUnitTest.java

@@ -0,0 +1,24 @@
+package com.baeldung.stringisnumeric;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+
+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/src/test/java/com/baeldung/stringjoiner/StringJoinerUnitTest.java

@@ -0,0 +1,101 @@
+package com.baeldung.stringjoiner;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.StringJoiner;
+import java.util.stream.Collectors;
+
+import org.junit.Test;
+
+public class StringJoinerUnitTest {
+    private final String DELIMITER_COMMA = ",";
+    private final String DELIMITER_HYPHEN = "-";
+    private final String PREFIX = "[";
+    private final String SUFFIX = "]";
+    private final String EMPTY_JOINER = "empty";
+
+    @Test
+    public void whenJoinerWithoutPrefixSuffixWithoutEmptyValue_thenReturnDefault() {
+        StringJoiner commaSeparatedJoiner = new StringJoiner(DELIMITER_COMMA);
+        assertEquals(0, commaSeparatedJoiner.toString().length());
+    }
+
+    @Test
+    public void whenJoinerWithPrefixSuffixWithoutEmptyValue_thenReturnDefault() {
+        StringJoiner commaSeparatedPrefixSuffixJoiner = new StringJoiner(DELIMITER_COMMA, PREFIX, SUFFIX);
+        assertEquals(commaSeparatedPrefixSuffixJoiner.toString(), PREFIX + SUFFIX);
+    }
+
+    @Test
+    public void whenJoinerWithoutPrefixSuffixWithEmptyValue_thenReturnDefault() {
+        StringJoiner commaSeparatedJoiner = new StringJoiner(DELIMITER_COMMA);
+        commaSeparatedJoiner.setEmptyValue(EMPTY_JOINER);
+
+        assertEquals(commaSeparatedJoiner.toString(), EMPTY_JOINER);
+    }
+
+    @Test
+    public void whenJoinerWithPrefixSuffixWithEmptyValue_thenReturnDefault() {
+        StringJoiner commaSeparatedPrefixSuffixJoiner = new StringJoiner(DELIMITER_COMMA, PREFIX, SUFFIX);
+        commaSeparatedPrefixSuffixJoiner.setEmptyValue(EMPTY_JOINER);
+
+        assertEquals(commaSeparatedPrefixSuffixJoiner.toString(), EMPTY_JOINER);
+    }
+
+    @Test
+    public void whenAddElements_thenJoinElements() {
+        StringJoiner rgbJoiner = new StringJoiner(DELIMITER_COMMA, PREFIX, SUFFIX);
+        rgbJoiner.add("Red")
+          .add("Green")
+          .add("Blue");
+
+        assertEquals(rgbJoiner.toString(), "[Red,Green,Blue]");
+    }
+
+    @Test
+    public void whenAddListElements_thenJoinListElements() {
+        List<String> rgbList = new ArrayList<String>();
+        rgbList.add("Red");
+        rgbList.add("Green");
+        rgbList.add("Blue");
+
+        StringJoiner rgbJoiner = new StringJoiner(DELIMITER_COMMA, PREFIX, SUFFIX);
+
+        for (String color : rgbList) {
+            rgbJoiner.add(color);
+        }
+
+        assertEquals(rgbJoiner.toString(), "[Red,Green,Blue]");
+    }
+
+    @Test
+    public void whenMergeJoiners_thenReturnMerged() {
+        StringJoiner rgbJoiner = new StringJoiner(DELIMITER_COMMA, PREFIX, SUFFIX);
+        StringJoiner cmybJoiner = new StringJoiner(DELIMITER_HYPHEN, PREFIX, SUFFIX);
+
+        rgbJoiner.add("Red")
+          .add("Green")
+          .add("Blue");
+        cmybJoiner.add("Cyan")
+          .add("Magenta")
+          .add("Yellow")
+          .add("Black");
+
+        rgbJoiner.merge(cmybJoiner);
+
+        assertEquals(rgbJoiner.toString(), "[Red,Green,Blue,Cyan-Magenta-Yellow-Black]");
+    }
+
+    @Test
+    public void whenUsedWithinCollectors_thenJoin() {
+        List<String> rgbList = Arrays.asList("Red", "Green", "Blue");
+        String commaSeparatedRGB = rgbList.stream()
+          .map(color -> color.toString())
+          .collect(Collectors.joining(","));
+
+        assertEquals(commaSeparatedRGB, "Red,Green,Blue");
+    }
+}

java-strings/src/test/java/com/baeldung/stringtokenizer/TokenizerUnitTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.stringtokenizer;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class TokenizerUnitTest {
+
+	private final MyTokenizer myTokenizer = new MyTokenizer();
+	private final List<String> expectedTokensForString = Arrays.asList("Welcome", "to", "baeldung.com");
+	private final List<String> expectedTokensForFile = Arrays.asList("1", "IND", "India", "2", "MY", "Malaysia", "3", "AU", "Australia");
+
+	@Test
+	public void givenString_thenGetListOfString() {
+		String str = "Welcome,to,baeldung.com";
+		List<String> actualTokens = myTokenizer.getTokens(str);
+		assertEquals(expectedTokensForString, actualTokens);
+	}
+
+	@Test
+	public void givenFile_thenGetListOfString() {
+		List<String> actualTokens = myTokenizer.getTokensFromFile("data.csv", "|");
+		assertEquals(expectedTokensForFile, actualTokens);
+	}
+
+}