5 Unique JUnit Test Cases for Apache Commons Text Project

src/test/java/RandomStringGenerator_EquivalenceTest.java

@@ -0,0 +1,43 @@
+package org.apache.commons.text;
+
+import org.apache.commons.text.RandomStringGenerator.Builder;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class RandomStringGenerator_EquivalenceTest {
+
+    @Test
+    void testGenerateNegativeLength() {
+        RandomStringGenerator generator = new Builder().build();
+        assertThrows(IllegalArgumentException.class, () -> generator.generate(-1));
+    }
+
+    @Test
+    void testGenerateLengthZero() {
+        RandomStringGenerator generator = new Builder().build();
+        String result = generator.generate(0);
+        assertNotNull(result);
+        assertEquals(0, result.length());
+    }
+
+    @Test
+    void testGenerateLengthOne() {
+        RandomStringGenerator generator = new Builder()
+                .withinRange('a', 'z')  // ? Ensures length matches input
+                .build();
+        String result = generator.generate(1);
+        assertNotNull(result);
+        assertEquals(1, result.length());
+    }
+
+    @Test
+    void testGenerateValidLength() {
+        RandomStringGenerator generator = new Builder()
+                .withinRange('a', 'z')
+                .build();
+        String result = generator.generate(10);
+        assertNotNull(result);
+        assertEquals(10, result.length());
+    }
+}

src/test/java/StringTokenizer_PathTest.java

@@ -0,0 +1,55 @@
+package org.apache.commons.text;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.NoSuchElementException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class StringTokenizer_PathTest {
+
+    @Test
+    void testEmptyInput() {
+        StringTokenizer tokenizer = new StringTokenizer("");
+        assertFalse(tokenizer.hasNext());
+    }
+
+    @Test
+    void testTrailingDelimiter() {
+        StringTokenizer tokenizer = new StringTokenizer("a,", ',');
+        assertTrue(tokenizer.hasNext());
+        assertEquals("a", tokenizer.next());
+        assertFalse(tokenizer.hasNext()); // Avoid NoSuchElementException
+    }
+
+    @Test
+    void testMultipleTokensCustomDelimiter() {
+        StringTokenizer tokenizer = new StringTokenizer("x|y|z", '|');
+        assertEquals("x", tokenizer.next());
+        assertEquals("y", tokenizer.next());
+        assertEquals("z", tokenizer.next());
+    }
+
+    @Test
+    void testMultipleTokensDefaultDelimiter() {
+        StringTokenizer tokenizer = new StringTokenizer("a b c");
+        assertEquals("a", tokenizer.next());
+        assertEquals("b", tokenizer.next());
+        assertEquals("c", tokenizer.next());
+    }
+
+    @Test
+    void testConsecutiveDelimiters() {
+        StringTokenizer tokenizer = new StringTokenizer("a,,b", ',');
+        assertEquals("a", tokenizer.next());
+        assertEquals("b", tokenizer.next());  // previously missing
+        assertFalse(tokenizer.hasNext());
+    }
+
+    @Test
+    void testSingleToken() {
+        StringTokenizer tokenizer = new StringTokenizer("onlyOneToken");
+        assertEquals("onlyOneToken", tokenizer.next());
+        assertFalse(tokenizer.hasNext());
+    }
+}

src/test/java/org/apache/commons/text/CharacterPredicatesDataFlowTest.java

@@ -0,0 +1,48 @@
+package org.apache.commons.text;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class CharacterPredicatesDataFlowTest {
+
+    // Test case: lowercase alphabetic character (e.g., 'g' => ASCII 103)
+    @Test
+    void testLowercaseAlphabetic() {
+        int codePoint = 'g';
+        boolean result = CharacterPredicates.ASCII_ALPHA_NUMERALS.test(codePoint);
+        assertTrue(result, "Expected 'g' to be alphanumeric.");
+    }
+
+    // Test case: uppercase alphabetic character (e.g., 'Z' => ASCII 90)
+    @Test
+    void testUppercaseAlphabetic() {
+        int codePoint = 'Z';
+        boolean result = CharacterPredicates.ASCII_ALPHA_NUMERALS.test(codePoint);
+        assertTrue(result, "Expected 'Z' to be alphanumeric.");
+    }
+
+    // Test case: numeric character (e.g., '5' => ASCII 53)
+    @Test
+    void testNumericCharacter() {
+        int codePoint = '5';
+        boolean result = CharacterPredicates.ASCII_ALPHA_NUMERALS.test(codePoint);
+        assertTrue(result, "Expected '5' to be alphanumeric.");
+    }
+
+    // Test case: symbol (e.g., '#' => ASCII 35), should return false
+    @Test
+    void testSymbolCharacter() {
+        int codePoint = '#';
+        boolean result = CharacterPredicates.ASCII_ALPHA_NUMERALS.test(codePoint);
+        assertFalse(result, "Expected '#' not to be alphanumeric.");
+    }
+
+    // Test case: non-ASCII character (e.g., '�' => ASCII 241), should return false
+    @Test
+    void testNonAsciiCharacter() {
+        int codePoint = '�';
+        boolean result = CharacterPredicates.ASCII_ALPHA_NUMERALS.test(codePoint);
+        assertFalse(result, "Expected '�' not to be alphanumeric.");
+    }
+}

src/test/java/org/apache/commons/text/StrBuilder_BlackBoxTest.java

@@ -0,0 +1,43 @@
+package org.apache.commons.text;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class StrBuilder_BlackBoxTest {
+
+    @Test
+    void testReverseEmptyString() {
+        StrBuilder builder = new StrBuilder("");
+        builder.reverse();
+        assertEquals("", builder.toString());
+    }
+
+    @Test
+    void testReverseSingleCharacter() {
+        StrBuilder builder = new StrBuilder("A");
+        builder.reverse();
+        assertEquals("A", builder.toString());
+    }
+
+    @Test
+    void testReversePalindrome() {
+        StrBuilder builder = new StrBuilder("madam");
+        builder.reverse();
+        assertEquals("madam", builder.toString());
+    }
+
+    @Test
+    void testReverseSimpleWord() {
+        StrBuilder builder = new StrBuilder("hello");
+        builder.reverse();
+        assertEquals("olleh", builder.toString());
+    }
+
+    @Test
+    void testReverseWithSpecialCharacters() {
+        StrBuilder builder = new StrBuilder("a@b#c$");
+        builder.reverse();
+        assertEquals("$c#b@a", builder.toString());
+    }
+}

src/test/java/org/apache/commons/text/StringEscapeUtils_BoundaryTest.java

@@ -0,0 +1,43 @@
+package org.apache.commons.text;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class StringEscapeUtils_BoundaryTest {
+
+    @Test
+    void testEscapeEmptyString() {
+        String input = "";
+        String result = StringEscapeUtils.escapeHtml4(input);
+        assertEquals("", result);
+    }
+
+    @Test
+    void testEscapeSingleChar() {
+        String input = "<";
+        String result = StringEscapeUtils.escapeHtml4(input);
+        assertEquals("&lt;", result);
+    }
+
+    @Test
+    void testEscapeCommonHtml() {
+        String input = "<div>Hello & Goodbye</div>";
+        String result = StringEscapeUtils.escapeHtml4(input);
+        assertEquals("&lt;div&gt;Hello &amp; Goodbye&lt;/div&gt;", result);
+    }
+
+    @Test
+    void testEscapeLargeInput() {
+        // Java 8 compatible: use StringBuilder instead of repeat()
+        StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < 333; i++) {
+            builder.append("<>&");
+        }
+        builder.append("<");
+        String input = builder.toString();
+
+        String result = StringEscapeUtils.escapeHtml4(input);
+        assertTrue(result.length() > input.length());
+    }
+}