You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2022/05/29 12:33:50 UTC
[commons-text] 01/06: Remove noisy inline comments.
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
commit 6c4e1bc3060862b4fde7c9084845f6ed4e83efa8
Author: Gary Gregory <ga...@gmail.com>
AuthorDate: Sun May 29 08:08:18 2022 -0400
Remove noisy inline comments.
---
.../java/org/apache/commons/text/StrBuilder.java | 1 -
.../org/apache/commons/text/StringEscapeUtils.java | 2 -
.../org/apache/commons/text/CaseUtilsTest.java | 2 -
.../commons/text/StrBuilderAppendInsertTest.java | 49 --------
.../org/apache/commons/text/StrBuilderTest.java | 138 +++++++--------------
.../org/apache/commons/text/StrLookupTest.java | 1 -
.../org/apache/commons/text/StrMatcherTest.java | 14 ---
.../apache/commons/text/StrSubstitutorTest.java | 6 -
.../org/apache/commons/text/StrTokenizerTest.java | 60 +++------
.../apache/commons/text/StringEscapeUtilsTest.java | 2 -
.../apache/commons/text/StringTokenizerTest.java | 60 +++------
.../org/apache/commons/text/WordUtilsTest.java | 33 ++---
.../text/matcher/StringMatcherOnCharArrayTest.java | 3 +-
.../StringMatcherOnCharSequenceStringTest.java | 3 +-
14 files changed, 99 insertions(+), 275 deletions(-)
diff --git a/src/main/java/org/apache/commons/text/StrBuilder.java b/src/main/java/org/apache/commons/text/StrBuilder.java
index 599017a3..551ff241 100644
--- a/src/main/java/org/apache/commons/text/StrBuilder.java
+++ b/src/main/java/org/apache/commons/text/StrBuilder.java
@@ -994,7 +994,6 @@ public class StrBuilder implements CharSequence, Appendable, Serializable, Build
return append(value).appendNewLine();
}
- //-----------------------------------------------------------------------
/**
* Appends an object followed by a new line to this string builder.
* Appending null will call {@link #appendNull()}.
diff --git a/src/main/java/org/apache/commons/text/StringEscapeUtils.java b/src/main/java/org/apache/commons/text/StringEscapeUtils.java
index 0c616288..08441585 100644
--- a/src/main/java/org/apache/commons/text/StringEscapeUtils.java
+++ b/src/main/java/org/apache/commons/text/StringEscapeUtils.java
@@ -558,7 +558,6 @@ public class StringEscapeUtils {
}
// HTML and XML
- //--------------------------------------------------------------------------
/**
* Escapes the characters in a {@code String} using HTML entities.
*
@@ -589,7 +588,6 @@ public class StringEscapeUtils {
}
// Java and JavaScript
- //--------------------------------------------------------------------------
/**
* Escapes the characters in a {@code String} using Java String rules.
*
diff --git a/src/test/java/org/apache/commons/text/CaseUtilsTest.java b/src/test/java/org/apache/commons/text/CaseUtilsTest.java
index c0883f80..742c9fd7 100644
--- a/src/test/java/org/apache/commons/text/CaseUtilsTest.java
+++ b/src/test/java/org/apache/commons/text/CaseUtilsTest.java
@@ -28,7 +28,6 @@ import org.junit.jupiter.api.Test;
*/
public class CaseUtilsTest {
- //-----------------------------------------------------------------------
@Test
public void testConstructor() {
assertThat(new CaseUtils()).isNotNull();
@@ -39,7 +38,6 @@ public class CaseUtilsTest {
assertThat(Modifier.isFinal(CaseUtils.class.getModifiers())).isFalse();
}
- //------------------------------------------------------------------------
@Test
public void testToCamelCase() {
assertThat(CaseUtils.toCamelCase(null, false, null)).isNull();
diff --git a/src/test/java/org/apache/commons/text/StrBuilderAppendInsertTest.java b/src/test/java/org/apache/commons/text/StrBuilderAppendInsertTest.java
index 71bc7572..b7625f18 100644
--- a/src/test/java/org/apache/commons/text/StrBuilderAppendInsertTest.java
+++ b/src/test/java/org/apache/commons/text/StrBuilderAppendInsertTest.java
@@ -49,7 +49,6 @@ public class StrBuilderAppendInsertTest {
}
};
- //-----------------------------------------------------------------------
@Test
public void testAppend_Boolean() {
final StrBuilder sb = new StrBuilder();
@@ -63,7 +62,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("truefalse!");
}
- //-----------------------------------------------------------------------
@Test
public void testAppend_CharArray() {
StrBuilder sb = new StrBuilder();
@@ -78,7 +76,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foo");
}
- //-----------------------------------------------------------------------
@Test
public void testAppend_CharArray_int_int() {
StrBuilder sb = new StrBuilder();
@@ -138,7 +135,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foobar");
}
- //-----------------------------------------------------------------------
@Test
public void testAppend_FormattedString() {
StrBuilder sb;
@@ -163,7 +159,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo(expected);
}
- //-----------------------------------------------------------------------
@Test
public void testAppend_Object() {
final StrBuilder sb = new StrBuilder();
@@ -192,7 +187,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foobazyesSeqbld");
}
- //-----------------------------------------------------------------------
@Test
public void testAppend_PrimitiveNumber() {
final StrBuilder sb = new StrBuilder();
@@ -209,7 +203,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("012.34.5");
}
- //-----------------------------------------------------------------------
@Test
public void testAppend_StrBuilder() {
StrBuilder sb = new StrBuilder();
@@ -227,7 +220,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foobar");
}
- //-----------------------------------------------------------------------
@Test
public void testAppend_StrBuilder_int_int() {
StrBuilder sb = new StrBuilder();
@@ -287,7 +279,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foobar");
}
- //-----------------------------------------------------------------------
@Test
public void testAppend_String() {
StrBuilder sb = new StrBuilder();
@@ -305,7 +296,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foobar");
}
- //-----------------------------------------------------------------------
@Test
public void testAppend_String_int_int() {
StrBuilder sb = new StrBuilder();
@@ -368,7 +358,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foobarard");
}
- //-----------------------------------------------------------------------
@Test
public void testAppend_StringBuffer() {
StrBuilder sb = new StrBuilder();
@@ -386,7 +375,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foobar");
}
- //-----------------------------------------------------------------------
@Test
public void testAppend_StringBuffer_int_int() {
StrBuilder sb = new StrBuilder();
@@ -446,7 +434,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foobar");
}
- //-----------------------------------------------------------------------
@Test
public void testAppend_StringBuilder() {
StrBuilder sb = new StrBuilder();
@@ -464,7 +451,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foobar");
}
- //-----------------------------------------------------------------------
@Test
public void testAppend_StringBuilder_int_int() {
StrBuilder sb = new StrBuilder();
@@ -527,7 +513,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foobarard");
}
- //-----------------------------------------------------------------------
@Test
public void testAppendAll_Array() {
final StrBuilder sb = new StrBuilder();
@@ -547,7 +532,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foobarbaz");
}
- //-----------------------------------------------------------------------
@Test
public void testAppendAll_Collection() {
final StrBuilder sb = new StrBuilder();
@@ -563,7 +547,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foobarbaz");
}
- //-----------------------------------------------------------------------
@Test
public void testAppendAll_Iterator() {
final StrBuilder sb = new StrBuilder();
@@ -579,7 +562,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foobarbaz");
}
- //-----------------------------------------------------------------------
@Test
public void testAppendFixedWidthPadLeft() {
final StrBuilder sb = new StrBuilder();
@@ -618,7 +600,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("-null");
}
- //-----------------------------------------------------------------------
@Test
public void testAppendFixedWidthPadLeft_int() {
final StrBuilder sb = new StrBuilder();
@@ -652,7 +633,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("-------123");
}
- //-----------------------------------------------------------------------
@Test
public void testAppendFixedWidthPadRight() {
final StrBuilder sb = new StrBuilder();
@@ -691,7 +671,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("null-");
}
- //-----------------------------------------------------------------------
@Test
public void testAppendFixedWidthPadRight_int() {
final StrBuilder sb = new StrBuilder();
@@ -725,7 +704,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("123-------");
}
- //-----------------------------------------------------------------------
@Test
public void testAppendln_Boolean() {
final StrBuilder sb = new StrBuilder();
@@ -737,7 +715,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("false" + SEP);
}
- //-----------------------------------------------------------------------
@Test
public void testAppendln_CharArray() {
final int[] count = new int[2];
@@ -761,7 +738,6 @@ public class StrBuilderAppendInsertTest {
assertThat(count[1]).isEqualTo(1);
}
- //-----------------------------------------------------------------------
@Test
public void testAppendln_CharArray_int_int() {
final int[] count = new int[2];
@@ -785,7 +761,6 @@ public class StrBuilderAppendInsertTest {
assertThat(count[1]).isEqualTo(1);
}
- //-----------------------------------------------------------------------
@Test
public void testAppendln_FormattedString() {
final int[] count = new int[2];
@@ -809,7 +784,6 @@ public class StrBuilderAppendInsertTest {
assertThat(count[1]).isEqualTo(1);
}
- //-----------------------------------------------------------------------
@Test
public void testAppendln_Object() {
final StrBuilder sb = new StrBuilder();
@@ -823,7 +797,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo(SEP + "foo" + SEP + "6" + SEP);
}
- //-----------------------------------------------------------------------
@Test
public void testAppendln_PrimitiveNumber() {
final StrBuilder sb = new StrBuilder();
@@ -843,7 +816,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("4.5" + SEP);
}
- //-----------------------------------------------------------------------
@Test
public void testAppendln_StrBuilder() {
final int[] count = new int[2];
@@ -867,7 +839,6 @@ public class StrBuilderAppendInsertTest {
assertThat(count[1]).isEqualTo(1);
}
- //-----------------------------------------------------------------------
@Test
public void testAppendln_StrBuilder_int_int() {
final int[] count = new int[2];
@@ -891,7 +862,6 @@ public class StrBuilderAppendInsertTest {
assertThat(count[1]).isEqualTo(1);
}
- //-----------------------------------------------------------------------
@Test
public void testAppendln_String() {
final int[] count = new int[2];
@@ -915,7 +885,6 @@ public class StrBuilderAppendInsertTest {
assertThat(count[1]).isEqualTo(1);
}
- //-----------------------------------------------------------------------
@Test
public void testAppendln_String_int_int() {
final int[] count = new int[2];
@@ -939,7 +908,6 @@ public class StrBuilderAppendInsertTest {
assertThat(count[1]).isEqualTo(1);
}
- //-----------------------------------------------------------------------
@Test
public void testAppendln_StringBuffer() {
final int[] count = new int[2];
@@ -963,7 +931,6 @@ public class StrBuilderAppendInsertTest {
assertThat(count[1]).isEqualTo(1);
}
- //-----------------------------------------------------------------------
@Test
public void testAppendln_StringBuffer_int_int() {
final int[] count = new int[2];
@@ -987,7 +954,6 @@ public class StrBuilderAppendInsertTest {
assertThat(count[1]).isEqualTo(1);
}
- //-----------------------------------------------------------------------
@Test
public void testAppendln_StringBuilder() {
final int[] count = new int[2];
@@ -1011,7 +977,6 @@ public class StrBuilderAppendInsertTest {
assertThat(count[1]).isEqualTo(1);
}
- //-----------------------------------------------------------------------
@Test
public void testAppendln_StringBuilder_int_int() {
final int[] count = new int[2];
@@ -1035,7 +1000,6 @@ public class StrBuilderAppendInsertTest {
assertThat(count[1]).isEqualTo(1);
}
- //-----------------------------------------------------------------------
@Test
public void testAppendNewLine() {
StrBuilder sb = new StrBuilder("---");
@@ -1047,7 +1011,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("---#" + SEP);
}
- //-----------------------------------------------------------------------
@Test
public void testAppendPadding() {
final StrBuilder sb = new StrBuilder();
@@ -1069,7 +1032,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foo-----------------");
}
- //-----------------------------------------------------------------------
@Test
public void testAppendSeparator_char() {
final StrBuilder sb = new StrBuilder();
@@ -1095,7 +1057,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo(String.valueOf(startSeparator) + foo + standardSeparator);
}
- //-----------------------------------------------------------------------
@Test
public void testAppendSeparator_char_int() {
final StrBuilder sb = new StrBuilder();
@@ -1110,7 +1071,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foo,");
}
- //-----------------------------------------------------------------------
@Test
public void testAppendSeparator_String() {
final StrBuilder sb = new StrBuilder();
@@ -1122,7 +1082,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foo,");
}
- //-----------------------------------------------------------------------
@Test
public void testAppendSeparator_String_int() {
final StrBuilder sb = new StrBuilder();
@@ -1137,7 +1096,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foo,");
}
- //-----------------------------------------------------------------------
@Test
public void testAppendSeparator_String_String() {
final StrBuilder sb = new StrBuilder();
@@ -1160,7 +1118,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo(startSeparator + foo + standardSeparator);
}
- //-----------------------------------------------------------------------
@Test
public void testAppendWithNullText() {
final StrBuilder sb = new StrBuilder();
@@ -1192,7 +1149,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("NULLNULLfooNULLbarNULLbaz");
}
- //-----------------------------------------------------------------------
@Test
public void testAppendWithSeparators_Array() {
final StrBuilder sb = new StrBuilder();
@@ -1216,7 +1172,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foo,,baz");
}
- //-----------------------------------------------------------------------
@Test
public void testAppendWithSeparators_Collection() {
final StrBuilder sb = new StrBuilder();
@@ -1239,7 +1194,6 @@ public class StrBuilderAppendInsertTest {
sb.appendWithSeparators(Arrays.asList("foo", null, "baz"), ",");
assertThat(sb.toString()).isEqualTo("foo,,baz");
}
- //-----------------------------------------------------------------------
@Test
public void testAppendWithSeparators_Iterator() {
final StrBuilder sb = new StrBuilder();
@@ -1263,7 +1217,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foo,,baz");
}
- //-----------------------------------------------------------------------
@Test
public void testAppendWithSeparatorsWithNullText() {
final StrBuilder sb = new StrBuilder();
@@ -1276,7 +1229,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("foo,null,baz");
}
- //-----------------------------------------------------------------------
@Test
public void testInsert() {
@@ -1429,7 +1381,6 @@ public class StrBuilderAppendInsertTest {
assertThat(sb.toString()).isEqualTo("4.5barbaz");
}
- //-----------------------------------------------------------------------
@Test
public void testInsertWithNullText() {
final StrBuilder sb = new StrBuilder();
diff --git a/src/test/java/org/apache/commons/text/StrBuilderTest.java b/src/test/java/org/apache/commons/text/StrBuilderTest.java
index a6cbc6f0..d30cb139 100644
--- a/src/test/java/org/apache/commons/text/StrBuilderTest.java
+++ b/src/test/java/org/apache/commons/text/StrBuilderTest.java
@@ -84,8 +84,7 @@ public class StrBuilderTest {
assertFalse(sb.equals(other));
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testAppendCharBuffer() {
final StrBuilder sb1 = new StrBuilder();
final CharBuffer buf = CharBuffer.allocate(10);
@@ -234,8 +233,7 @@ public class StrBuilderTest {
assertEquals("Test 1234567890", builder.toString());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testAppendToWriter() throws Exception {
final StrBuilder sb = new StrBuilder("1234567890");
final StringWriter writer = new StringWriter();
@@ -252,8 +250,7 @@ public class StrBuilderTest {
assertEquals(sb.toString(), sb.build());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testAsReader() throws Exception {
final StrBuilder sb = new StrBuilder("some text");
try (Reader reader = sb.asReader()) {
@@ -336,8 +333,7 @@ public class StrBuilderTest {
}
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testAsTokenizer() throws Exception {
// from Javadoc
final StrBuilder b = new StrBuilder();
@@ -375,8 +371,7 @@ public class StrBuilderTest {
assertEquals("a b c d ", t.getContent());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testAsWriter() throws Exception {
final StrBuilder sb = new StrBuilder("base");
try (Writer writer = sb.asWriter()) {
@@ -411,8 +406,7 @@ public class StrBuilderTest {
}
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testCapacity() {
final StrBuilder sb = new StrBuilder();
assertEquals(sb.buffer.length, sb.capacity());
@@ -421,8 +415,7 @@ public class StrBuilderTest {
assertEquals(sb.buffer.length, sb.capacity());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testCapacityAndLength() {
final StrBuilder sb = new StrBuilder();
assertEquals(32, sb.capacity());
@@ -501,8 +494,7 @@ public class StrBuilderTest {
assertTrue(sb.isEmpty());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testChaining() {
final StrBuilder sb = new StrBuilder();
assertSame(sb, sb.setNewLineText(null));
@@ -516,8 +508,7 @@ public class StrBuilderTest {
assertSame(sb, sb.trim());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testCharAt() {
final StrBuilder sb = new StrBuilder();
assertThrows(IndexOutOfBoundsException.class, () -> sb.charAt(0));
@@ -539,8 +530,7 @@ public class StrBuilderTest {
assertTrue(sb.buffer.length >= 5);
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testConstructors() {
final StrBuilder sb0 = new StrBuilder();
assertEquals(32, sb0.capacity());
@@ -583,8 +573,7 @@ public class StrBuilderTest {
assertEquals(3, sb7.size());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testContains_char() {
final StrBuilder sb = new StrBuilder("abcdefghijklmnopqrstuvwxyz");
assertTrue(sb.contains('a'));
@@ -618,8 +607,7 @@ public class StrBuilderTest {
assertTrue(sb.contains(A_NUMBER_MATCHER));
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testDeleteAll_char() {
StrBuilder sb = new StrBuilder("abcbccba");
sb.deleteAll('X');
@@ -636,8 +624,7 @@ public class StrBuilderTest {
assertEquals("", sb.toString());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testDeleteAll_String() {
StrBuilder sb = new StrBuilder("abcbccba");
sb.deleteAll((String) null);
@@ -663,8 +650,7 @@ public class StrBuilderTest {
assertEquals("", sb.toString());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testDeleteAll_StrMatcher() {
StrBuilder sb = new StrBuilder("A0xA1A2yA3");
sb.deleteAll((StrMatcher) null);
@@ -681,8 +667,7 @@ public class StrBuilderTest {
assertEquals("", sb.toString());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testDeleteCharAt() {
final StrBuilder sb = new StrBuilder("abc");
sb.deleteCharAt(0);
@@ -756,8 +741,7 @@ public class StrBuilderTest {
assertEquals("", sb.toString());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testDeleteIntInt() {
final StrBuilder sb = new StrBuilder("abc");
sb.delete(0, 1);
@@ -806,8 +790,7 @@ public class StrBuilderTest {
assertTrue(sb.capacity() >= 40);
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testEquals() {
final StrBuilder sb1 = new StrBuilder();
final StrBuilder sb2 = new StrBuilder();
@@ -832,8 +815,7 @@ public class StrBuilderTest {
assertNotEquals("abc", sb1);
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testEqualsIgnoreCase() {
final StrBuilder sb1 = new StrBuilder();
final StrBuilder sb2 = new StrBuilder();
@@ -926,8 +908,7 @@ public class StrBuilderTest {
}
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testGetSetNewLineText() {
final StrBuilder sb = new StrBuilder();
assertNull(sb.getNewLineText());
@@ -942,8 +923,7 @@ public class StrBuilderTest {
assertNull(sb.getNewLineText());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testGetSetNullText() {
final StrBuilder sb = new StrBuilder();
assertNull(sb.getNullText());
@@ -961,8 +941,7 @@ public class StrBuilderTest {
assertNull(sb.getNullText());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testHashCode() {
final StrBuilder sb = new StrBuilder();
final int hc1a = sb.hashCode();
@@ -977,8 +956,7 @@ public class StrBuilderTest {
assertEquals(hc2a, hc2b);
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testIndexOf_char() {
final StrBuilder sb = new StrBuilder("abab");
assertEquals(0, sb.indexOf('a'));
@@ -1014,8 +992,7 @@ public class StrBuilderTest {
assertEquals(-1, sb.indexOf('z', 3));
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testIndexOf_String() {
final StrBuilder sb = new StrBuilder("abab");
@@ -1075,8 +1052,7 @@ public class StrBuilderTest {
assertEquals(-1, sb.indexOf((String) null, 2));
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testIndexOf_StrMatcher() {
final StrBuilder sb = new StrBuilder();
assertEquals(-1, sb.indexOf((StrMatcher) null));
@@ -1153,16 +1129,14 @@ public class StrBuilderTest {
assertTrue(sb.isEmpty());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testLang294() {
final StrBuilder sb = new StrBuilder("\n%BLAH%\nDo more stuff\neven more stuff\n%BLAH%\n");
sb.deleteAll("\n%BLAH%");
assertEquals("\nDo more stuff\neven more stuff\n", sb.toString());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testLang295() {
final StrBuilder sb = new StrBuilder("onetwothree");
sb.deleteFirst("three");
@@ -1177,8 +1151,7 @@ public class StrBuilderTest {
assertEquals("**********", sb.toString(), "Failed to invoke appendFixedWidthPadLeft correctly");
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testLang412Right() {
final StrBuilder sb = new StrBuilder();
sb.appendFixedWidthPadRight(null, 10, '*');
@@ -1351,8 +1324,7 @@ public class StrBuilderTest {
assertEquals("left right", sb.leftString(15));
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testLength() {
final StrBuilder sb = new StrBuilder();
assertEquals(0, sb.length());
@@ -1361,8 +1333,7 @@ public class StrBuilderTest {
assertEquals(5, sb.length());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testMidString() {
final StrBuilder sb = new StrBuilder("hello goodbye hello");
assertEquals("goodbye", sb.midString(6, 7));
@@ -1426,8 +1397,7 @@ public class StrBuilderTest {
assertEquals("Test 123", sb.toString());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testReadFromReader() throws Exception {
String s = "";
for (int i = 0; i < 100; ++i) {
@@ -1448,8 +1418,7 @@ public class StrBuilderTest {
assertEquals("Test 123", sb.toString());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testReplace_int_int_String() {
StrBuilder sb = new StrBuilder("abc");
sb.replace(0, 1, "d");
@@ -1577,8 +1546,7 @@ public class StrBuilderTest {
assertEquals("aaxaaaayaa", sb.toString());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testReplace_StrMatcher_String_int_int_int_VaryMatcher() {
StrBuilder sb = new StrBuilder("abcbccba");
sb.replace((StrMatcher) null, "x", 0, sb.length(), -1);
@@ -1687,8 +1655,7 @@ public class StrBuilderTest {
assertEquals("aaxaaaayaa", sb.toString());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testReplaceAll_char_char() {
final StrBuilder sb = new StrBuilder("abcbccba");
sb.replaceAll('x', 'y');
@@ -1703,8 +1670,7 @@ public class StrBuilderTest {
assertEquals("defeffed", sb.toString());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testReplaceAll_String_String() {
StrBuilder sb = new StrBuilder("abcbccba");
sb.replaceAll((String) null, null);
@@ -1734,8 +1700,7 @@ public class StrBuilderTest {
assertEquals("xbxxbx", sb.toString());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testReplaceAll_StrMatcher_String() {
StrBuilder sb = new StrBuilder("abcbccba");
sb.replaceAll((StrMatcher) null, null);
@@ -1773,8 +1738,7 @@ public class StrBuilderTest {
assertEquals("Dear 012345678901234567, hello 012345678901234567.", sb.toString());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testReplaceFirst_char_char() {
final StrBuilder sb = new StrBuilder("abcbccba");
sb.replaceFirst('x', 'y');
@@ -1853,8 +1817,7 @@ public class StrBuilderTest {
assertEquals("***-A2A3-A4", sb.toString());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testReverse() {
final StrBuilder sb = new StrBuilder();
assertEquals("", sb.reverse().toString());
@@ -1873,8 +1836,7 @@ public class StrBuilderTest {
assertEquals("left right", sb.rightString(15));
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testSetCharAt() {
final StrBuilder sb = new StrBuilder();
assertThrows(IndexOutOfBoundsException.class, () -> sb.setCharAt(0, 'f'));
@@ -1901,8 +1863,7 @@ public class StrBuilderTest {
assertThrows(IndexOutOfBoundsException.class, () -> sb.setLength(-1));
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testSize() {
final StrBuilder sb = new StrBuilder();
assertEquals(0, sb.size());
@@ -1911,8 +1872,7 @@ public class StrBuilderTest {
assertEquals(5, sb.size());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testStartsWith() {
final StrBuilder sb = new StrBuilder();
assertFalse(sb.startsWith("a"));
@@ -1925,8 +1885,7 @@ public class StrBuilderTest {
assertFalse(sb.startsWith("cba"));
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testSubSequenceIntInt() {
final StrBuilder sb = new StrBuilder("hello goodbye");
// Start index is negative
@@ -1976,8 +1935,7 @@ public class StrBuilderTest {
assertThrows(IndexOutOfBoundsException.class, () -> sb.substring(15, 20));
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testToCharArray() {
final StrBuilder sb = new StrBuilder();
assertEquals(0, sb.toCharArray().length);
@@ -2018,15 +1976,13 @@ public class StrBuilderTest {
assertThrows(IndexOutOfBoundsException.class, () -> sb.toCharArray(6, 5));
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testToString() {
final StrBuilder sb = new StrBuilder("abc");
assertEquals("abc", sb.toString());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testToStringBuffer() {
final StrBuilder sb = new StrBuilder();
assertEquals(new StringBuffer().toString(), sb.toStringBuffer().toString());
@@ -2035,8 +1991,7 @@ public class StrBuilderTest {
assertEquals(new StringBuffer("junit").toString(), sb.toStringBuffer().toString());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testToStringBuilder() {
final StrBuilder sb = new StrBuilder();
assertEquals(new StringBuilder().toString(), sb.toStringBuilder().toString());
@@ -2045,8 +2000,7 @@ public class StrBuilderTest {
assertEquals(new StringBuilder("junit").toString(), sb.toStringBuilder().toString());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testTrim() {
final StrBuilder sb = new StrBuilder();
assertEquals("", sb.reverse().toString());
diff --git a/src/test/java/org/apache/commons/text/StrLookupTest.java b/src/test/java/org/apache/commons/text/StrLookupTest.java
index 44ae9a32..121ee518 100644
--- a/src/test/java/org/apache/commons/text/StrLookupTest.java
+++ b/src/test/java/org/apache/commons/text/StrLookupTest.java
@@ -55,7 +55,6 @@ public class StrLookupTest {
assertNull(StrLookup.mapLookup(map).lookup("any"));
}
- //-----------------------------------------------------------------------
@Test
public void testNoneLookup() {
assertNull(StrLookup.noneLookup().lookup(null));
diff --git a/src/test/java/org/apache/commons/text/StrMatcherTest.java b/src/test/java/org/apache/commons/text/StrMatcherTest.java
index c51d1bbb..a85fd03b 100644
--- a/src/test/java/org/apache/commons/text/StrMatcherTest.java
+++ b/src/test/java/org/apache/commons/text/StrMatcherTest.java
@@ -33,7 +33,6 @@ public class StrMatcherTest {
private static final char[] BUFFER2 = "abcdef".toCharArray();
- //-----------------------------------------------------------------------
@Test
public void testCharMatcher_char() {
final StrMatcher matcher = StrMatcher.charMatcher('c');
@@ -45,7 +44,6 @@ public class StrMatcherTest {
assertThat(matcher.isMatch(BUFFER2, 5)).isEqualTo(0);
}
- //-----------------------------------------------------------------------
@Test
public void testCharSetMatcher_charArray() {
final StrMatcher matcher = StrMatcher.charSetMatcher("ace".toCharArray());
@@ -60,7 +58,6 @@ public class StrMatcherTest {
assertThat(StrMatcher.charSetMatcher("a".toCharArray()) instanceof StrMatcher.CharMatcher).isTrue();
}
- //-----------------------------------------------------------------------
@Test
public void testCharSetMatcher_String() {
final StrMatcher matcher = StrMatcher.charSetMatcher("ace");
@@ -75,7 +72,6 @@ public class StrMatcherTest {
assertThat(StrMatcher.charSetMatcher("a") instanceof StrMatcher.CharMatcher).isTrue();
}
- //-----------------------------------------------------------------------
@Test
public void testCommaMatcher() {
final StrMatcher matcher = StrMatcher.commaMatcher();
@@ -85,7 +81,6 @@ public class StrMatcherTest {
assertThat(matcher.isMatch(BUFFER1, 2)).isEqualTo(0);
}
- //-----------------------------------------------------------------------
@Test
public void testDoubleQuoteMatcher() {
final StrMatcher matcher = StrMatcher.doubleQuoteMatcher();
@@ -94,7 +89,6 @@ public class StrMatcherTest {
assertThat(matcher.isMatch(BUFFER1, 12)).isEqualTo(1);
}
- //-----------------------------------------------------------------------
@Test
public void testMatcherIndices() {
// remember that the API contract is tight for the isMatch() method
@@ -106,7 +100,6 @@ public class StrMatcherTest {
assertThat(matcher.isMatch(BUFFER2, 1, 0, 2)).isEqualTo(0);
}
- //-----------------------------------------------------------------------
@Test
public void testNoneMatcher() {
final StrMatcher matcher = StrMatcher.noneMatcher();
@@ -126,7 +119,6 @@ public class StrMatcherTest {
assertThat(matcher.isMatch(BUFFER1, 12)).isEqualTo(0);
}
- //-----------------------------------------------------------------------
@Test
public void testQuoteMatcher() {
final StrMatcher matcher = StrMatcher.quoteMatcher();
@@ -136,7 +128,6 @@ public class StrMatcherTest {
assertThat(matcher.isMatch(BUFFER1, 12)).isEqualTo(1);
}
- //-----------------------------------------------------------------------
@Test
public void testSingleQuoteMatcher() {
final StrMatcher matcher = StrMatcher.singleQuoteMatcher();
@@ -146,7 +137,6 @@ public class StrMatcherTest {
assertThat(matcher.isMatch(BUFFER1, 12)).isEqualTo(0);
}
- //-----------------------------------------------------------------------
@Test
public void testSpaceMatcher() {
final StrMatcher matcher = StrMatcher.spaceMatcher();
@@ -156,7 +146,6 @@ public class StrMatcherTest {
assertThat(matcher.isMatch(BUFFER1, 6)).isEqualTo(0);
}
- //-----------------------------------------------------------------------
@Test
public void testSplitMatcher() {
final StrMatcher matcher = StrMatcher.splitMatcher();
@@ -172,7 +161,6 @@ public class StrMatcherTest {
assertThat(matcher.isMatch(BUFFER1, 10)).isEqualTo(0);
}
- //-----------------------------------------------------------------------
@Test
public void testStringMatcher_String() {
final StrMatcher matcher = StrMatcher.stringMatcher("bc");
@@ -186,7 +174,6 @@ public class StrMatcherTest {
assertThat(StrMatcher.stringMatcher((String) null)).isSameAs(StrMatcher.noneMatcher());
}
- //-----------------------------------------------------------------------
@Test
public void testTabMatcher() {
final StrMatcher matcher = StrMatcher.tabMatcher();
@@ -196,7 +183,6 @@ public class StrMatcherTest {
assertThat(matcher.isMatch(BUFFER1, 4)).isEqualTo(0);
}
- //-----------------------------------------------------------------------
@Test
public void testTrimMatcher() {
final StrMatcher matcher = StrMatcher.trimMatcher();
diff --git a/src/test/java/org/apache/commons/text/StrSubstitutorTest.java b/src/test/java/org/apache/commons/text/StrSubstitutorTest.java
index efa0ab22..7bd64868 100644
--- a/src/test/java/org/apache/commons/text/StrSubstitutorTest.java
+++ b/src/test/java/org/apache/commons/text/StrSubstitutorTest.java
@@ -74,7 +74,6 @@ public class StrSubstitutorTest {
doTestReplace(sub, expectedResult, replaceTemplate, substring);
}
- //-----------------------------------------------------------------------
private void doTestReplace(final StrSubstitutor sub, final String expectedResult, final String replaceTemplate,
final boolean substring) {
final String expectedShortResult = expectedResult.substring(1, expectedResult.length() - 1);
@@ -184,7 +183,6 @@ public class StrSubstitutorTest {
assertEquals("Hi < commons", sub.replace("Hi $< <name>"));
}
- //-----------------------------------------------------------------------
/**
* Tests constructor.
*/
@@ -276,7 +274,6 @@ public class StrSubstitutorTest {
doTestReplace(sub, "The ${critter} jumps over the ${pet}.", "The ${animal} jumps over the ${target}.", true);
}
- //-----------------------------------------------------------------------
/**
* Tests get set.
*/
@@ -613,7 +610,6 @@ public class StrSubstitutorTest {
doTestReplace("The quick brown fox jumps over the lazy dog.", "The ${animal} jumps over the ${target}.", true);
}
- //-----------------------------------------------------------------------
/**
* Tests simple key replace.
*/
@@ -696,7 +692,6 @@ public class StrSubstitutorTest {
doTestNoReplace("${${ }}");
}
- //-----------------------------------------------------------------------
/**
* Tests protected.
*/
@@ -730,7 +725,6 @@ public class StrSubstitutorTest {
assertEquals("Hello there commons!", StrSubstitutor.replace("@greeting@ there @name@!", map, "@", "@"));
}
- //-----------------------------------------------------------------------
/**
* Tests static.
*/
diff --git a/src/test/java/org/apache/commons/text/StrTokenizerTest.java b/src/test/java/org/apache/commons/text/StrTokenizerTest.java
index 606811a3..5ec97b6d 100644
--- a/src/test/java/org/apache/commons/text/StrTokenizerTest.java
+++ b/src/test/java/org/apache/commons/text/StrTokenizerTest.java
@@ -49,8 +49,7 @@ public class StrTokenizerTest {
assertNotSame(StrTokenizer.getTSVInstance(), tokenizer);
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void test1() {
final String input = "a;b;c;\"d;\"\"e\";f; ; ; ";
@@ -496,8 +495,7 @@ public class StrTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testChaining() {
final StrTokenizer tok = new StrTokenizer();
assertEquals(tok, tok.reset());
@@ -561,8 +559,7 @@ public class StrTokenizerTest {
assertEquals("a", clonedTokenizer.nextToken());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testConstructor_charArray() {
StrTokenizer tok = new StrTokenizer("a b".toCharArray());
assertEquals("a", tok.next());
@@ -576,8 +573,7 @@ public class StrTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testConstructor_charArray_char() {
StrTokenizer tok = new StrTokenizer("a b".toCharArray(), ' ');
assertEquals(1, tok.getDelimiterMatcher().isMatch(" ".toCharArray(), 0, 0, 1));
@@ -592,8 +588,7 @@ public class StrTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testConstructor_charArray_char_char() {
StrTokenizer tok = new StrTokenizer("a b".toCharArray(), ' ', '"');
assertEquals(1, tok.getDelimiterMatcher().isMatch(" ".toCharArray(), 0, 0, 1));
@@ -609,8 +604,7 @@ public class StrTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testConstructor_String() {
StrTokenizer tok = new StrTokenizer("a b");
assertEquals("a", tok.next());
@@ -624,8 +618,7 @@ public class StrTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testConstructor_String_char() {
StrTokenizer tok = new StrTokenizer("a b", ' ');
assertEquals(1, tok.getDelimiterMatcher().isMatch(" ".toCharArray(), 0, 0, 1));
@@ -640,8 +633,7 @@ public class StrTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testConstructor_String_char_char() {
StrTokenizer tok = new StrTokenizer("a b", ' ', '"');
assertEquals(1, tok.getDelimiterMatcher().isMatch(" ".toCharArray(), 0, 0, 1));
@@ -657,8 +649,7 @@ public class StrTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- private void testCSV(final String data) {
+ private void testCSV(final String data) {
this.testXSVAbc(StrTokenizer.getCSVInstance(data));
this.testXSVAbc(StrTokenizer.getCSVInstance(data.toCharArray()));
}
@@ -766,8 +757,7 @@ public class StrTokenizerTest {
assertFalse(tkn.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testListArray() {
final String input = "a b c";
final StrTokenizer tok = new StrTokenizer(input);
@@ -786,8 +776,7 @@ public class StrTokenizerTest {
assertNull(strTokenizer.previousToken());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testReset() {
final StrTokenizer tok = new StrTokenizer("a b c");
assertEquals("a", tok.next());
@@ -802,8 +791,7 @@ public class StrTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testReset_charArray() {
final StrTokenizer tok = new StrTokenizer("x x x");
@@ -816,8 +804,7 @@ public class StrTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testReset_String() {
final StrTokenizer tok = new StrTokenizer("x x x");
tok.reset("d e");
@@ -829,16 +816,14 @@ public class StrTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testStringTokenizerQuoteMatcher() {
final char[] chars = {'\'', 'a', 'c', '\'', 'd'};
final StrTokenizer tokens = new StrTokenizer(chars, StrMatcher.commaMatcher(), StrMatcher.quoteMatcher());
assertEquals("acd", tokens.next());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testStringTokenizerStringMatcher() {
final char[] chars = {'a', 'b', 'c', 'd'};
final StrTokenizer tokens = new StrTokenizer(chars, "bc");
@@ -846,8 +831,7 @@ public class StrTokenizerTest {
assertEquals("d", tokens.next());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testStringTokenizerStrMatcher() {
final char[] chars = {'a', ',', 'c'};
final StrTokenizer tokens = new StrTokenizer(chars, StrMatcher.commaMatcher());
@@ -855,8 +839,7 @@ public class StrTokenizerTest {
assertEquals("c", tokens.next());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testTokenizeSubclassInputChange() {
final StrTokenizer tkn = new StrTokenizer("a b c d e") {
@@ -869,8 +852,7 @@ public class StrTokenizerTest {
assertEquals("y", tkn.next());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testTokenizeSubclassOutputChange() {
final StrTokenizer tkn = new StrTokenizer("a b c") {
@@ -886,8 +868,7 @@ public class StrTokenizerTest {
assertEquals("a", tkn.next());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testToString() {
final StrTokenizer tkn = new StrTokenizer("a b c d e");
assertEquals("StrTokenizer[not tokenized yet]", tkn.toString());
@@ -895,8 +876,7 @@ public class StrTokenizerTest {
assertEquals("StrTokenizer[a, b, c, d, e]", tkn.toString());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testTSV() {
this.testXSVAbc(StrTokenizer.getTSVInstance(TSV_SIMPLE_FIXTURE));
this.testXSVAbc(StrTokenizer.getTSVInstance(TSV_SIMPLE_FIXTURE.toCharArray()));
diff --git a/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java b/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java
index 62217229..8c2a231a 100644
--- a/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java
+++ b/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java
@@ -134,8 +134,6 @@ public class StringEscapeUtilsTest {
// HTML and XML
- //--------------------------------------------------------------
-
@Test
public void testDeleteCharacter() {
final String deleteString = "Delete: \u007F";
diff --git a/src/test/java/org/apache/commons/text/StringTokenizerTest.java b/src/test/java/org/apache/commons/text/StringTokenizerTest.java
index db38f966..6bf97887 100644
--- a/src/test/java/org/apache/commons/text/StringTokenizerTest.java
+++ b/src/test/java/org/apache/commons/text/StringTokenizerTest.java
@@ -48,8 +48,7 @@ public class StringTokenizerTest {
assertNotSame(StringTokenizer.getTSVInstance(), tokenizer);
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void test1() {
final String input = "a;b;c;\"d;\"\"e\";f; ; ; ";
@@ -495,8 +494,7 @@ public class StringTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testChaining() {
final StringTokenizer tok = new StringTokenizer();
assertEquals(tok, tok.reset());
@@ -560,8 +558,7 @@ public class StringTokenizerTest {
assertEquals("a", clonedTokenizer.nextToken());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testConstructor_charArray() {
StringTokenizer tok = new StringTokenizer("a b".toCharArray());
assertEquals("a", tok.next());
@@ -575,8 +572,7 @@ public class StringTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testConstructor_charArray_char() {
StringTokenizer tok = new StringTokenizer("a b".toCharArray(), ' ');
assertEquals(1, tok.getDelimiterMatcher().isMatch(" ".toCharArray(), 0, 0, 1));
@@ -592,8 +588,7 @@ public class StringTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testConstructor_charArray_char_char() {
StringTokenizer tok = new StringTokenizer("a b".toCharArray(), ' ', '"');
assertEquals(1, tok.getDelimiterMatcher().isMatch(" ".toCharArray(), 0, 0, 1));
@@ -611,8 +606,7 @@ public class StringTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testConstructor_String() {
StringTokenizer tok = new StringTokenizer("a b");
assertEquals("a", tok.next());
@@ -626,8 +620,7 @@ public class StringTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testConstructor_String_char() {
StringTokenizer tok = new StringTokenizer("a b", ' ');
assertEquals(1, tok.getDelimiterMatcher().isMatch(" ".toCharArray(), 0, 0, 1));
@@ -643,8 +636,7 @@ public class StringTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testConstructor_String_char_char() {
StringTokenizer tok = new StringTokenizer("a b", ' ', '"');
assertEquals(1, tok.getDelimiterMatcher().isMatch(" ".toCharArray(), 0, 0, 1));
@@ -662,8 +654,7 @@ public class StringTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- private void testCSV(final String data) {
+ private void testCSV(final String data) {
this.testXSVAbc(StringTokenizer.getCSVInstance(data));
this.testXSVAbc(StringTokenizer.getCSVInstance(data.toCharArray()));
}
@@ -771,8 +762,7 @@ public class StringTokenizerTest {
assertFalse(tkn.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testListArray() {
final String input = "a b c";
final StringTokenizer tok = new StringTokenizer(input);
@@ -791,8 +781,7 @@ public class StringTokenizerTest {
assertNull(strTokenizer.previousToken());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testReset() {
final StringTokenizer tok = new StringTokenizer("a b c");
assertEquals("a", tok.next());
@@ -807,8 +796,7 @@ public class StringTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testReset_charArray() {
final StringTokenizer tok = new StringTokenizer("x x x");
@@ -821,8 +809,7 @@ public class StringTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testReset_String() {
final StringTokenizer tok = new StringTokenizer("x x x");
tok.reset("d e");
@@ -834,8 +821,7 @@ public class StringTokenizerTest {
assertFalse(tok.hasNext());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testStringTokenizerQuoteMatcher() {
final char[] chars = {'\'', 'a', 'c', '\'', 'd' };
final StringTokenizer tokens = new StringTokenizer(chars, StringMatcherFactory.INSTANCE.commaMatcher(),
@@ -843,8 +829,7 @@ public class StringTokenizerTest {
assertEquals("acd", tokens.next());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testStringTokenizerStringMatcher() {
final char[] chars = {'a', 'b', 'c', 'd' };
final StringTokenizer tokens = new StringTokenizer(chars, "bc");
@@ -852,8 +837,7 @@ public class StringTokenizerTest {
assertEquals("d", tokens.next());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testStringTokenizerStrMatcher() {
final char[] chars = {'a', ',', 'c' };
final StringTokenizer tokens = new StringTokenizer(chars, StringMatcherFactory.INSTANCE.commaMatcher());
@@ -861,8 +845,7 @@ public class StringTokenizerTest {
assertEquals("c", tokens.next());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testTokenizeSubclassInputChange() {
final StringTokenizer tkn = new StringTokenizer("a b c d e") {
@@ -875,8 +858,7 @@ public class StringTokenizerTest {
assertEquals("y", tkn.next());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testTokenizeSubclassOutputChange() {
final StringTokenizer tkn = new StringTokenizer("a b c") {
@@ -892,8 +874,7 @@ public class StringTokenizerTest {
assertEquals("a", tkn.next());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testToString() {
final StringTokenizer tkn = new StringTokenizer("a b c d e");
assertEquals("StringTokenizer[not tokenized yet]", tkn.toString());
@@ -901,8 +882,7 @@ public class StringTokenizerTest {
assertEquals("StringTokenizer[a, b, c, d, e]", tkn.toString());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testTSV() {
this.testXSVAbc(StringTokenizer.getTSVInstance(TSV_SIMPLE_FIXTURE));
this.testXSVAbc(StringTokenizer.getTSVInstance(TSV_SIMPLE_FIXTURE.toCharArray()));
diff --git a/src/test/java/org/apache/commons/text/WordUtilsTest.java b/src/test/java/org/apache/commons/text/WordUtilsTest.java
index d287a13b..15f3b0e6 100644
--- a/src/test/java/org/apache/commons/text/WordUtilsTest.java
+++ b/src/test/java/org/apache/commons/text/WordUtilsTest.java
@@ -36,8 +36,7 @@ public class WordUtilsTest {
assertThatIllegalArgumentException().isThrownBy(() -> assertThat(WordUtils.abbreviate("01 23 45 67 89", 9, -10, null)).isEqualTo("01 23 45 67"));
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testAbbreviateForLowerValue() {
assertThat(WordUtils.abbreviate("012 3456789", 0, 5, null)).isEqualTo("012");
assertThat(WordUtils.abbreviate("01234 56789", 5, 10, null)).isEqualTo("01234");
@@ -46,8 +45,7 @@ public class WordUtilsTest {
assertThat(WordUtils.abbreviate("0123456789", 15, 20, null)).isEqualTo("0123456789");
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testAbbreviateForLowerValueAndAppendedString() {
assertThat(WordUtils.abbreviate("012 3456789", 0, 5, null)).isEqualTo("012");
assertThat(WordUtils.abbreviate("01234 56789", 5, 10, "-")).isEqualTo("01234-");
@@ -55,8 +53,7 @@ public class WordUtilsTest {
assertThat(WordUtils.abbreviate("01 23 45 67 89", 9, 10, "")).isEqualTo("01 23 45 6");
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testAbbreviateForNullAndEmptyString() {
assertThat((WordUtils.abbreviate(null, 1, -1, ""))).isNull();
assertThat(WordUtils.abbreviate("", 1, -1, "")).isEqualTo(StringUtils.EMPTY);
@@ -64,16 +61,14 @@ public class WordUtilsTest {
assertThat(WordUtils.abbreviate(" 0123456790", 0, -1, "")).isEqualTo("");
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testAbbreviateForUpperLimit() {
assertThat(WordUtils.abbreviate("0123456789", 0, 5, "")).isEqualTo("01234");
assertThat(WordUtils.abbreviate("012 3456789", 2, 5, "")).isEqualTo("012");
assertThat(WordUtils.abbreviate("0123456789", 0, -1, "")).isEqualTo("0123456789");
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testAbbreviateForUpperLimitAndAppendedString() {
assertThat(WordUtils.abbreviate("0123456789", 0, 5, "-")).isEqualTo("01234-");
assertThat(WordUtils.abbreviate("012 3456789", 2, 5, null)).isEqualTo("012");
@@ -85,8 +80,7 @@ public class WordUtilsTest {
assertThatIllegalArgumentException().isThrownBy(() -> assertThat(WordUtils.abbreviate("0123456789", 5, 2, "")).isEqualTo("01234"));
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testCapitalize_String() {
assertThat(WordUtils.capitalize(null)).isNull();
assertThat(WordUtils.capitalize("")).isEqualTo("");
@@ -158,8 +152,7 @@ public class WordUtilsTest {
assertThat(WordUtils.capitalize("i am.fine", null)).isEqualTo("I Am.fine");
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testConstructor() {
assertThat(new WordUtils()).isNotNull();
final Constructor<?>[] cons = WordUtils.class.getDeclaredConstructors();
@@ -195,8 +188,7 @@ public class WordUtilsTest {
assertThat(WordUtils.containsAllWords("M", (CharSequence) null)).isFalse();
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testInitials_String() {
assertThat(WordUtils.initials(null)).isNull();
assertThat(WordUtils.initials("")).isEqualTo("");
@@ -211,8 +203,7 @@ public class WordUtilsTest {
assertThat(WordUtils.initials("i am here 123")).isEqualTo("iah1");
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testInitials_String_charArray() {
char[] array = null;
assertThat(WordUtils.initials(null, array)).isNull();
@@ -335,8 +326,7 @@ public class WordUtilsTest {
assertThat(WordUtils.abbreviate("01 23 45 67 89", 40, 40, "")).isEqualTo("01 23 45 67 89");
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testSwapCase_String() {
assertThat(WordUtils.swapCase(null)).isNull();
assertThat(WordUtils.swapCase("")).isEqualTo("");
@@ -398,8 +388,7 @@ public class WordUtilsTest {
assertThat(WordUtils.uncapitalize("I AM.FINE", null)).isEqualTo("i aM.FINE");
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testWrap_StringInt() {
assertThat(WordUtils.wrap(null, 20)).isNull();
assertThat(WordUtils.wrap(null, -1)).isNull();
diff --git a/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharArrayTest.java b/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharArrayTest.java
index b23e5bf7..a2512ee2 100644
--- a/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharArrayTest.java
+++ b/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharArrayTest.java
@@ -317,8 +317,7 @@ public class StringMatcherOnCharArrayTest {
testStringMatcher_String(StringMatcherFactory.INSTANCE.stringMatcher("bc"));
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testTabMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.tabMatcher();
assertEquals(1, matcher.size());
diff --git a/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharSequenceStringTest.java b/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharSequenceStringTest.java
index fd0da141..c460c65e 100644
--- a/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharSequenceStringTest.java
+++ b/src/test/java/org/apache/commons/text/matcher/StringMatcherOnCharSequenceStringTest.java
@@ -308,8 +308,7 @@ public class StringMatcherOnCharSequenceStringTest {
.isSameAs(StringMatcherFactory.INSTANCE.noneMatcher());
}
- // -----------------------------------------------------------------------
- @Test
+ @Test
public void testTabMatcher() {
final StringMatcher matcher = StringMatcherFactory.INSTANCE.tabMatcher();
assertEquals(1, matcher.size());