This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-text.git
The following commit(s) were added to refs/heads/master by this push:
new 9e34d3d2 Add more test coverage (#732)
9e34d3d2 is described below
commit 9e34d3d2b2f58c35937477d859042920cdaf3a00
Author: Dominik Stadler <[email protected]>
AuthorDate: Fri Dec 12 13:49:13 2025 +0100
Add more test coverage (#732)
* Enable test which can be enabled now
* Ensure test does not fail on non-US default locale
* Cover a few lines/branches
Add some more tests to cover a bit more.
Also apply some IDE-suggestions, assert-order,
simplify assertions.
* Adjust based on review comments
Remove added @Deprecated
Remove comments which silence warnings in IDEs
Inline local variables
* Revert "Ensure test does not fail on non-US default locale"
This reverts commit 5a6af9ed28cc7523044150a5b57b109fbfc28cd8.
* Some more minor adjustments of added tests based on code review
---
.../java/org/apache/commons/text/OssFuzzTest.java | Bin 16930 -> 16771 bytes
.../apache/commons/text/StringSubstitutorTest.java | 8 +++++-
.../apache/commons/text/TextStringBuilderTest.java | 7 +++++
.../org/apache/commons/text/WordUtilsTest.java | 28 ++++++++++++++++++-
.../text/lookup/StringLookupFactoryTest.java | 13 +++++++++
.../text/similarity/IntersectionResultTest.java | 5 +++-
.../text/similarity/LevenshteinResultsTest.java | 16 +++++++++++
.../similarity/LongestCommonSubsequenceTest.java | 4 +++
.../text/translate/CharSequenceTranslatorTest.java | 18 ++++++++++--
.../commons/text/translate/OctalUnescaperTest.java | 31 +++++++++++++++++++++
.../text/translate/SinglePassTranslatorTest.java | 14 ++++++++--
.../text/translate/UnicodeUnescaperTest.java | 5 ++++
12 files changed, 142 insertions(+), 7 deletions(-)
diff --git a/src/test/java/org/apache/commons/text/OssFuzzTest.java
b/src/test/java/org/apache/commons/text/OssFuzzTest.java
index 0b4e1a55..c3772e5a 100644
Binary files a/src/test/java/org/apache/commons/text/OssFuzzTest.java and
b/src/test/java/org/apache/commons/text/OssFuzzTest.java differ
diff --git a/src/test/java/org/apache/commons/text/StringSubstitutorTest.java
b/src/test/java/org/apache/commons/text/StringSubstitutorTest.java
index 75f112ba..4022fc3d 100644
--- a/src/test/java/org/apache/commons/text/StringSubstitutorTest.java
+++ b/src/test/java/org/apache/commons/text/StringSubstitutorTest.java
@@ -193,7 +193,7 @@ public class StringSubstitutorTest {
}
@AfterEach
- public void tearDown() throws Exception {
+ public void tearDown() {
values = null;
}
@@ -1085,4 +1085,10 @@ public class StringSubstitutorTest {
assertEqualsCharSeq("value $${escaped}", replace(sub, org));
}
+ @Test
+ void testToString() {
+ final StringSubstitutor s = new StringSubstitutor(null, "prefix",
"suffix");
+ String str = s.toString();
+ assertTrue(str.contains("\"prefix\""), "Had: " + str);
+ }
}
diff --git a/src/test/java/org/apache/commons/text/TextStringBuilderTest.java
b/src/test/java/org/apache/commons/text/TextStringBuilderTest.java
index ff2cc7d0..1900c19d 100644
--- a/src/test/java/org/apache/commons/text/TextStringBuilderTest.java
+++ b/src/test/java/org/apache/commons/text/TextStringBuilderTest.java
@@ -550,6 +550,13 @@ class TextStringBuilderTest {
assertEquals(length, sb.toCharArray().length);
}
+ @Test
+ void testConstructorCharSequenceNull() {
+ final TextStringBuilder sb = new TextStringBuilder((CharSequence)
null);
+ assertEquals(TextStringBuilder.CAPACITY, sb.capacity());
+ assertEquals(0, sb.toCharArray().length);
+ }
+
@Test
void testConstructorDefault() {
final TextStringBuilder sb = new TextStringBuilder();
diff --git a/src/test/java/org/apache/commons/text/WordUtilsTest.java
b/src/test/java/org/apache/commons/text/WordUtilsTest.java
index facbf31c..5ae96de4 100644
--- a/src/test/java/org/apache/commons/text/WordUtilsTest.java
+++ b/src/test/java/org/apache/commons/text/WordUtilsTest.java
@@ -177,14 +177,16 @@ class WordUtilsTest {
@Test
void testContainsAllWords_StringString() {
- assertFalse(WordUtils.containsAllWords(null, (String) null));
+ assertFalse(WordUtils.containsAllWords(null));
assertFalse(WordUtils.containsAllWords(null, ""));
assertFalse(WordUtils.containsAllWords(null, "ab"));
+ assertFalse(WordUtils.containsAllWords(""));
assertFalse(WordUtils.containsAllWords("", (String) null));
assertFalse(WordUtils.containsAllWords("", ""));
assertFalse(WordUtils.containsAllWords("", "ab"));
+ assertFalse(WordUtils.containsAllWords("foo"));
assertFalse(WordUtils.containsAllWords("foo", (String) null));
assertFalse(WordUtils.containsAllWords("bar", ""));
assertFalse(WordUtils.containsAllWords("zzabyycdxx", "by"));
@@ -321,6 +323,30 @@ class WordUtilsTest {
new char[] { '\uD800', '\uDF14', '\uD800', '\uDF18' }));
}
+ @Test
+ void testIsDelimiter() {
+ assertFalse(WordUtils.isDelimiter('.', null));
+ assertTrue(WordUtils.isDelimiter(' ', null));
+
+ assertFalse(WordUtils.isDelimiter(' ', new char[] { '.' }));
+ assertTrue(WordUtils.isDelimiter('.', new char[] { '.' }));
+
+ assertFalse(WordUtils.isDelimiter(' ', new char[] { '.', '_', 'a' }));
+ assertTrue(WordUtils.isDelimiter('.', new char[] { '.', '_', 'a', '.'
}));
+ }
+
+ @Test
+ void testIsDelimiterCodePoint() {
+ assertFalse(WordUtils.isDelimiter((int) '.', null));
+ assertTrue(WordUtils.isDelimiter((int) ' ', null));
+
+ assertFalse(WordUtils.isDelimiter((int) ' ', new char[] { '.' }));
+ assertTrue(WordUtils.isDelimiter((int) '.', new char[] { '.' }));
+
+ assertFalse(WordUtils.isDelimiter((int) ' ', new char[] { '.', '_',
'a' }));
+ assertTrue(WordUtils.isDelimiter((int) '.', new char[] { '.', '_',
'a', '.' }));
+ }
+
@Test
void testLANG1292() {
// Prior to fix, this was throwing StringIndexOutOfBoundsException
diff --git
a/src/test/java/org/apache/commons/text/lookup/StringLookupFactoryTest.java
b/src/test/java/org/apache/commons/text/lookup/StringLookupFactoryTest.java
index bdc6cac1..43e6f237 100644
--- a/src/test/java/org/apache/commons/text/lookup/StringLookupFactoryTest.java
+++ b/src/test/java/org/apache/commons/text/lookup/StringLookupFactoryTest.java
@@ -257,6 +257,14 @@ class StringLookupFactoryTest {
assertSame(XmlEncoderStringLookup.INSTANCE,
stringLookupFactory.xmlEncoderStringLookup());
}
+ /**
+ * Tests that we return the singleton.
+ */
+ @Test
+ void testDeprecatedSingletons() {
+ assertSame(StringLookupFactory.INSTANCE_BASE64_DECODER,
StringLookupFactory.INSTANCE.base64StringLookup());
+ }
+
@Test
void testXmlStringLookup() {
final StringLookupFactory stringLookupFactory =
StringLookupFactory.INSTANCE;
@@ -279,4 +287,9 @@ class StringLookupFactoryTest {
assertEquals(XmlStringLookupTest.DATA,
StringLookupFactory.INSTANCE.xmlStringLookup(XmlStringLookupTest.EMPTY_MAP).apply(key).trim());
}
+ @Test
+ void testClear() {
+ // this will clear out the global cache in ConstantStringLookup
+ StringLookupFactory.clear();
+ }
}
diff --git
a/src/test/java/org/apache/commons/text/similarity/IntersectionResultTest.java
b/src/test/java/org/apache/commons/text/similarity/IntersectionResultTest.java
index 5bb15d6b..70230b86 100644
---
a/src/test/java/org/apache/commons/text/similarity/IntersectionResultTest.java
+++
b/src/test/java/org/apache/commons/text/similarity/IntersectionResultTest.java
@@ -36,7 +36,7 @@ class IntersectionResultTest {
};
// Test a different instance with same values
- Assertions.assertEquals(results[0], new IntersectionResult(0, 0, 0));
+ Assertions.assertEquals(new IntersectionResult(0, 0, 0), results[0]);
final Object something = new Object();
for (int i = 0; i < results.length; i++) {
@@ -45,6 +45,9 @@ class IntersectionResultTest {
for (int j = 0; j < results.length; j++) {
Assertions.assertEquals(results[i].equals(results[j]), i == j);
}
+
+ Assertions.assertFalse(results[i].equals(null), "Should not be
Equal to null");
+ Assertions.assertNotEquals("Test", results[i], "Should not be
Equal to a different type of object");
}
}
diff --git
a/src/test/java/org/apache/commons/text/similarity/LevenshteinResultsTest.java
b/src/test/java/org/apache/commons/text/similarity/LevenshteinResultsTest.java
index af8f5d92..ac93db06 100644
---
a/src/test/java/org/apache/commons/text/similarity/LevenshteinResultsTest.java
+++
b/src/test/java/org/apache/commons/text/similarity/LevenshteinResultsTest.java
@@ -40,6 +40,15 @@ class LevenshteinResultsTest {
assertFalse(levenshteinResults.equals(levenshteinResultsTwo));
}
+ @Test
+ void testEqualsDifferentDistance() {
+ final Integer integerOne = 1662;
+ final Integer integerTwo = 1164;
+ final LevenshteinResults levenshteinResults = new
LevenshteinResults(integerOne, integerOne, integerOne, integerOne);
+ final LevenshteinResults levenshteinResultsTwo = new
LevenshteinResults(integerTwo, integerOne, integerOne, integerOne);
+ assertFalse(levenshteinResults.equals(levenshteinResultsTwo));
+ }
+
@Test
void testEqualsSameObject() {
final Integer integer = 1662;
@@ -62,4 +71,11 @@ class LevenshteinResultsTest {
assertFalse(levenshteinResults.equals(null));
}
+ @Test
+ void testEqualsWithDifferentObject() {
+ final Integer integer = -647;
+ final LevenshteinResults levenshteinResults = new
LevenshteinResults(integer, null, null, integer);
+ assertFalse(levenshteinResults.equals("Test"));
+ }
+
}
diff --git
a/src/test/java/org/apache/commons/text/similarity/LongestCommonSubsequenceTest.java
b/src/test/java/org/apache/commons/text/similarity/LongestCommonSubsequenceTest.java
index 2ca0a4b9..8063c911 100644
---
a/src/test/java/org/apache/commons/text/similarity/LongestCommonSubsequenceTest.java
+++
b/src/test/java/org/apache/commons/text/similarity/LongestCommonSubsequenceTest.java
@@ -89,6 +89,8 @@ class LongestCommonSubsequenceTest {
assertEquals("", subject.logestCommonSubsequence("", ""));
assertEquals("", subject.logestCommonSubsequence("left", ""));
assertEquals("", subject.logestCommonSubsequence("", "right"));
+ assertEquals("", subject.logestCommonSubsequence("l", "a"));
+ assertEquals("", subject.logestCommonSubsequence("left", "a"));
assertEquals("fog", subject.logestCommonSubsequence("frog", "fog"));
assertEquals("", subject.logestCommonSubsequence("fly", "ant"));
assertEquals("h", subject.logestCommonSubsequence("elephant",
"hippo"));
@@ -106,6 +108,8 @@ class LongestCommonSubsequenceTest {
assertEquals("", subject.longestCommonSubsequence("", ""));
assertEquals("", subject.longestCommonSubsequence("left", ""));
assertEquals("", subject.longestCommonSubsequence("", "right"));
+ assertEquals("", subject.longestCommonSubsequence("l", "a"));
+ assertEquals("", subject.longestCommonSubsequence("left", "a"));
assertEquals("fog", subject.longestCommonSubsequence("frog", "fog"));
assertEquals("", subject.longestCommonSubsequence("fly", "ant"));
assertEquals("h", subject.longestCommonSubsequence("elephant",
"hippo"));
diff --git
a/src/test/java/org/apache/commons/text/translate/CharSequenceTranslatorTest.java
b/src/test/java/org/apache/commons/text/translate/CharSequenceTranslatorTest.java
index 7585f71d..3bb33283 100644
---
a/src/test/java/org/apache/commons/text/translate/CharSequenceTranslatorTest.java
+++
b/src/test/java/org/apache/commons/text/translate/CharSequenceTranslatorTest.java
@@ -17,9 +17,11 @@
package org.apache.commons.text.translate;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import java.io.IOException;
+import java.io.UncheckedIOException;
import java.io.Writer;
import org.junit.jupiter.api.Test;
@@ -46,8 +48,20 @@ class CharSequenceTranslatorTest {
final CharSequenceTranslator charSequenceTranslatorThree = new
TestCharSequenceTranslator();
final CharSequenceTranslator aggregatedTranslator =
charSequenceTranslatorOne.with(charSequenceTranslatorTwo,
charSequenceTranslatorThree);
aggregatedTranslator.translate("", 0, null);
- assertTrue(aggregatedTranslator instanceof AggregateTranslator);
+ assertInstanceOf(AggregateTranslator.class, aggregatedTranslator);
assertEquals(3, translateInvocationCounter);
}
+ @Test
+ void testIOException() {
+ final CharSequenceTranslator translator = new CharSequenceTranslator()
{
+ @Override
+ public int translate(CharSequence input, int index, Writer writer)
throws IOException {
+ throw new IOException("Test exception");
+ }
+ };
+
+ assertThrows(UncheckedIOException.class,
+ () -> translator.translate("."));
+ }
}
diff --git
a/src/test/java/org/apache/commons/text/translate/OctalUnescaperTest.java
b/src/test/java/org/apache/commons/text/translate/OctalUnescaperTest.java
index e9b78b44..1f7d4b7b 100644
--- a/src/test/java/org/apache/commons/text/translate/OctalUnescaperTest.java
+++ b/src/test/java/org/apache/commons/text/translate/OctalUnescaperTest.java
@@ -38,6 +38,10 @@ class OctalUnescaperTest {
result = oue.translate(input);
assertEquals("\377", result, "Failed to unescape octal characters via
the between method");
+ input = "\\777";
+ result = oue.translate(input);
+ assertEquals("\777", result, "Failed to unescape octal characters via
the between method");
+
input = "\\377 and";
result = oue.translate(input);
assertEquals("\377 and", result, "Failed to unescape octal characters
via the between method");
@@ -79,4 +83,31 @@ class OctalUnescaperTest {
assertEquals("\\999", result, "Failed to ignore an out of range octal
character via the between method");
}
+ @Test
+ void testInvalid() {
+ final OctalUnescaper oue = new OctalUnescaper();
+ final String input = "\\4a";
+ final String result = oue.translate(input);
+ assertEquals("\4a", result, "Failed to unescape octal characters via
the between method");
+ }
+
+ @Test
+ void testHighLowSurrogate() {
+ final OctalUnescaper oue = new OctalUnescaper();
+ String input = "\\377\uD800and";
+ String result = oue.translate(input);
+ assertEquals("\377\uD800and", result, "Failed to unescape octal
characters via the between method");
+
+ input = "\\377\uD83D\uDE80and";
+ result = oue.translate(input);
+ assertEquals("\377\uD83D\uDE80and", result, "Failed to unescape octal
characters via the between method");
+
+ input = "\\377\uD83D\uDC00and";
+ result = oue.translate(input);
+ assertEquals("\377\uD83D\uDC00and", result, "Failed to unescape octal
characters via the between method");
+
+ input = "\\377\uD83D";
+ result = oue.translate(input);
+ assertEquals("\377\uD83D", result, "Failed to unescape octal
characters via the between method");
+ }
}
diff --git
a/src/test/java/org/apache/commons/text/translate/SinglePassTranslatorTest.java
b/src/test/java/org/apache/commons/text/translate/SinglePassTranslatorTest.java
index 37e6fdeb..12ade3f3 100644
---
a/src/test/java/org/apache/commons/text/translate/SinglePassTranslatorTest.java
+++
b/src/test/java/org/apache/commons/text/translate/SinglePassTranslatorTest.java
@@ -19,7 +19,6 @@ package org.apache.commons.text.translate;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
-import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
@@ -34,7 +33,7 @@ class SinglePassTranslatorTest {
private final SinglePassTranslator dummyTranslator = new
SinglePassTranslator() {
@Override
- void translateWhole(final CharSequence input, final Writer writer)
throws IOException {
+ void translateWhole(final CharSequence input, final Writer writer) {
// noop
}
};
@@ -63,4 +62,15 @@ class SinglePassTranslatorTest {
assertThrows(IllegalArgumentException.class, () ->
dummyTranslator.translate("(,Fk", 647, null));
}
+ @Test
+ void testTranslateThrowsIllegalArgumentExceptionWithNonAnonymousClass() {
+ assertThrows(IllegalArgumentException.class, () -> new
TestTranslator().translate("(,Fk", 647, null));
+ }
+
+ private static final class TestTranslator extends SinglePassTranslator {
+ @Override
+ void translateWhole(final CharSequence input, final Writer writer) {
+ // noop
+ }
+ }
}
diff --git
a/src/test/java/org/apache/commons/text/translate/UnicodeUnescaperTest.java
b/src/test/java/org/apache/commons/text/translate/UnicodeUnescaperTest.java
index cd106c66..f20d7106 100644
--- a/src/test/java/org/apache/commons/text/translate/UnicodeUnescaperTest.java
+++ b/src/test/java/org/apache/commons/text/translate/UnicodeUnescaperTest.java
@@ -49,4 +49,9 @@ class UnicodeUnescaperTest {
final String result = escaper.translate(input);
assertEquals("G", result, "Failed to unescape Unicode characters with
many 'u' characters");
}
+
+ @Test
+ void testTooShort() {
+ assertThrows(IllegalArgumentException.class, () -> new
UnicodeUnescaper().translate("\\u"));
+ }
}
