Remove dead in-line comments.

28 files changed, 0 insertions, 228 deletions

diff --git a/src/test/java/org/apache/commons/lang3/CharRangeTest.java b/src/test/java/org/apache/commons/lang3/CharRangeTest.java
index b3104fb71..76e1b87d3 100644
--- a/src/test/java/org/apache/commons/lang3/CharRangeTest.java
+++ b/src/test/java/org/apache/commons/lang3/CharRangeTest.java
@@ -36,7 +36,6 @@ import org.junit.jupiter.api.Test;
  */
 public class CharRangeTest  {
 
-    //-----------------------------------------------------------------------
     @Test
     public void testClass() {
         // class changed to non-public in 3.0
@@ -44,7 +43,6 @@ public class CharRangeTest  {
         assertTrue(Modifier.isFinal(CharRange.class.getModifiers()));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testConstructorAccessors_is() {
         final CharRange rangea = CharRange.is('a');
@@ -117,7 +115,6 @@ public class CharRangeTest  {
         assertEquals("^a-e", rangea.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testEquals_Object() {
         final CharRange rangea = CharRange.is('a');
@@ -162,7 +159,6 @@ public class CharRangeTest  {
         assertNotEquals(rangenotbf.hashCode(), rangeae.hashCode());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testContains_Char() {
         CharRange range = CharRange.is('c');
@@ -192,7 +188,6 @@ public class CharRangeTest  {
         assertTrue(range.contains(Character.MAX_VALUE));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testContains_Charrange() {
         final CharRange a = CharRange.is('a');
@@ -367,7 +362,6 @@ public class CharRangeTest  {
         assertThrows(NoSuchElementException.class, notLastIt::next);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testSerialization() {
         CharRange range = CharRange.is('a');
@@ -378,7 +372,6 @@ public class CharRangeTest  {
         assertEquals(range, SerializationUtils.clone(range));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testIteratorRemove() {
         final CharRange a = CharRange.is('a');
diff --git a/src/test/java/org/apache/commons/lang3/CharSequenceUtilsTest.java b/src/test/java/org/apache/commons/lang3/CharSequenceUtilsTest.java
index 214724ff7..9c3a5bec9 100644
--- a/src/test/java/org/apache/commons/lang3/CharSequenceUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/CharSequenceUtilsTest.java
@@ -41,7 +41,6 @@ import org.junit.jupiter.params.provider.MethodSource;
  */
 public class CharSequenceUtilsTest {
 
-    //-----------------------------------------------------------------------
     @Test
     public void testConstructor() {
         assertNotNull(new CharSequenceUtils());
@@ -52,7 +51,6 @@ public class CharSequenceUtilsTest {
         assertFalse(Modifier.isFinal(CharSequenceUtils.class.getModifiers()));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testSubSequence() {
         //
diff --git a/src/test/java/org/apache/commons/lang3/CharSetTest.java b/src/test/java/org/apache/commons/lang3/CharSetTest.java
index 966cc20f6..56c39d85c 100644
--- a/src/test/java/org/apache/commons/lang3/CharSetTest.java
+++ b/src/test/java/org/apache/commons/lang3/CharSetTest.java
@@ -34,14 +34,12 @@ import org.junit.jupiter.api.Test;
  */
 public class CharSetTest  {
 
-    //-----------------------------------------------------------------------
     @Test
     public void testClass() {
         assertTrue(Modifier.isPublic(CharSet.class.getModifiers()));
         assertFalse(Modifier.isFinal(CharSet.class.getModifiers()));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testGetInstance() {
         assertSame(CharSet.EMPTY, CharSet.getInstance( (String) null));
@@ -53,7 +51,6 @@ public class CharSetTest  {
         assertSame(CharSet.ASCII_NUMERIC, CharSet.getInstance("0-9"));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testGetInstance_Stringarray() {
         assertNull(CharSet.getInstance((String[]) null));
@@ -62,7 +59,6 @@ public class CharSetTest  {
         assertEquals("[a-e]", CharSet.getInstance(new String[] {"a-e"}).toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testConstructor_String_simple() {
         CharSet set;
@@ -340,7 +336,6 @@ public class CharSetTest  {
         assertFalse(set.contains('c'));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testEquals_Object() {
         final CharSet abc = CharSet.getInstance("abc");
@@ -385,7 +380,6 @@ public class CharSetTest  {
         assertEquals(notatoc.hashCode(), notatoc2.hashCode());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testContains_Char() {
         final CharSet btod = CharSet.getInstance("b-d");
@@ -429,7 +423,6 @@ public class CharSetTest  {
         assertEquals(1, array.length);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testSerialization() {
         CharSet set = CharSet.getInstance("a");
@@ -440,7 +433,6 @@ public class CharSetTest  {
         assertEquals(set, SerializationUtils.clone(set));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testStatics() {
         CharRange[] array;
diff --git a/src/test/java/org/apache/commons/lang3/CharSetUtilsTest.java b/src/test/java/org/apache/commons/lang3/CharSetUtilsTest.java
index 86c1e21ec..5754b9934 100644
--- a/src/test/java/org/apache/commons/lang3/CharSetUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/CharSetUtilsTest.java
@@ -32,7 +32,6 @@ import org.junit.jupiter.api.Test;
  */
 public class CharSetUtilsTest  {
 
-    //-----------------------------------------------------------------------
     @Test
     public void testConstructor() {
         assertNotNull(new CharSetUtils());
@@ -43,7 +42,6 @@ public class CharSetUtilsTest  {
         assertFalse(Modifier.isFinal(CharSetUtils.class.getModifiers()));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testSqueeze_StringString() {
         assertNull(CharSetUtils.squeeze(null, (String) null));
@@ -84,7 +82,6 @@ public class CharSetUtilsTest  {
         assertEquals("fof", CharSetUtils.squeeze("fooooff", "fo"));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testContainsAny_StringString() {
         assertFalse(CharSetUtils.containsAny(null, (String) null));
@@ -124,7 +121,6 @@ public class CharSetUtilsTest  {
         assertFalse(CharSetUtils.containsAny("hello", ""));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testCount_StringString() {
         assertEquals(0, CharSetUtils.count(null, (String) null));
@@ -164,7 +160,6 @@ public class CharSetUtilsTest  {
         assertEquals(0, CharSetUtils.count("hello", ""));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testKeep_StringString() {
         assertNull(CharSetUtils.keep(null, (String) null));
@@ -207,7 +202,6 @@ public class CharSetUtilsTest  {
         assertEquals("ll", CharSetUtils.keep("hello", "l"));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testDelete_StringString() {
         assertNull(CharSetUtils.delete(null, (String) null));
diff --git a/src/test/java/org/apache/commons/lang3/LocaleUtilsTest.java b/src/test/java/org/apache/commons/lang3/LocaleUtilsTest.java
index 8a8513d03..d8bd84dd1 100644
--- a/src/test/java/org/apache/commons/lang3/LocaleUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/LocaleUtilsTest.java
@@ -59,7 +59,6 @@ public class LocaleUtilsTest  {
         LocaleUtils.isAvailableLocale(Locale.getDefault());
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Test that constructors are public, and work, etc.
      */
@@ -73,7 +72,6 @@ public class LocaleUtilsTest  {
         assertFalse(Modifier.isFinal(LocaleUtils.class.getModifiers()));
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Pass in a valid language, test toLocale.
      *
@@ -221,7 +219,6 @@ public class LocaleUtilsTest  {
                 IllegalArgumentException.class, () -> LocaleUtils.toLocale("uu_UU_"), "Must be 3, 5 or 7+ in length");
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Helper method for local lookups.
      *
@@ -239,7 +236,6 @@ public class LocaleUtilsTest  {
         assertUnmodifiableCollection(localeList);
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Test localeLookupList() method.
      */
@@ -314,7 +310,6 @@ public class LocaleUtilsTest  {
                 LOCALE_EN});
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Test availableLocaleList() method.
      */
@@ -331,7 +326,6 @@ public class LocaleUtilsTest  {
         assertEquals(jdkLocaleList, list);
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Test availableLocaleSet() method.
      */
@@ -349,7 +343,6 @@ public class LocaleUtilsTest  {
         assertEquals(jdkLocaleSet, set);
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Test availableLocaleSet() method.
      */
@@ -381,7 +374,6 @@ public class LocaleUtilsTest  {
         }
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Make sure the language by country is correct. It checks that
      * the LocaleUtils.languagesByCountry(country) call contains the
@@ -428,7 +420,6 @@ public class LocaleUtilsTest  {
         assertLanguageByCountry("CH", new String[]{"fr", "de", "it"});
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Make sure the country by language is correct. It checks that
      * the LocaleUtils.countryByLanguage(language) call contains the
diff --git a/src/test/java/org/apache/commons/lang3/RandomStringUtilsTest.java b/src/test/java/org/apache/commons/lang3/RandomStringUtilsTest.java
index 4a5b36524..f358906b1 100644
--- a/src/test/java/org/apache/commons/lang3/RandomStringUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/RandomStringUtilsTest.java
@@ -41,7 +41,6 @@ import org.junit.jupiter.api.Test;
  */
 public class RandomStringUtilsTest {
 
-    //-----------------------------------------------------------------------
     @Test
     public void testConstructor() {
         assertNotNull(new RandomStringUtils());
@@ -52,7 +51,6 @@ public class RandomStringUtilsTest {
         assertFalse(Modifier.isFinal(RandomStringUtils.class.getModifiers()));
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Test the implementation
      */
diff --git a/src/test/java/org/apache/commons/lang3/SerializationUtilsTest.java b/src/test/java/org/apache/commons/lang3/SerializationUtilsTest.java
index a03b4597e..1c84ec68d 100644
--- a/src/test/java/org/apache/commons/lang3/SerializationUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/SerializationUtilsTest.java
@@ -62,7 +62,6 @@ public class SerializationUtilsTest {
         iMap.put("BAR", iInteger);
     }
 
-    //-----------------------------------------------------------------------
 
     @Test
     public void testConstructor() {
@@ -96,7 +95,6 @@ public class SerializationUtilsTest {
         assertSame(ex, serEx.getCause());
     }
 
-    //-----------------------------------------------------------------------
 
     @Test
     public void testSerializeStream() throws Exception {
@@ -164,7 +162,6 @@ public class SerializationUtilsTest {
         assertEquals("java.io.IOException: " + SERIALIZE_IO_EXCEPTION_MESSAGE, e.getMessage());
     }
 
-    //-----------------------------------------------------------------------
 
     @Test
     public void testDeserializeStream() throws Exception {
@@ -243,7 +240,6 @@ public class SerializationUtilsTest {
         assertEquals(iMap, newMap);
     }
 
-    //-----------------------------------------------------------------------
 
     @Test
     public void testSerializeBytes() throws Exception {
@@ -281,7 +277,6 @@ public class SerializationUtilsTest {
         assertArrayEquals(realBytes, testBytes);
     }
 
-    //-----------------------------------------------------------------------
 
     @Test
     public void testDeserializeBytes() throws Exception {
@@ -325,7 +320,6 @@ public class SerializationUtilsTest {
         assertThrows(SerializationException.class, () -> SerializationUtils.deserialize(new byte[0]));
     }
 
-    //-----------------------------------------------------------------------
 
     @Test
     public void testClone() {
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java
index daa112636..86f8702a7 100644
--- a/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java
+++ b/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java
@@ -198,7 +198,6 @@ public class StringUtilsEqualsIndexOfTest  {
         assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, new StringBuilder("fOo")));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testCompare_StringString() {
         assertEquals(0, StringUtils.compare(null, null));
@@ -267,7 +266,6 @@ public class StringUtilsEqualsIndexOfTest  {
         assertTrue(StringUtils.compareIgnoreCase("abc", "AB ", false) > 0);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testIndexOf_char() {
         assertEquals(-1, StringUtils.indexOf(null, ' '));
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsStartsEndsWithTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsStartsEndsWithTest.java
index b7e4cd842..6fa53d032 100644
--- a/src/test/java/org/apache/commons/lang3/StringUtilsStartsEndsWithTest.java
+++ b/src/test/java/org/apache/commons/lang3/StringUtilsStartsEndsWithTest.java
@@ -33,7 +33,6 @@ public class StringUtilsStartsEndsWithTest {
     private static final String BAR    = "BAR";
     private static final String FOOBAR = "FOOBAR";
 
-    //-----------------------------------------------------------------------
 
     /**
      * Test StringUtils.startsWith()
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsSubstringTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsSubstringTest.java
index 17c69fca6..0c49bdacf 100644
--- a/src/test/java/org/apache/commons/lang3/StringUtilsSubstringTest.java
+++ b/src/test/java/org/apache/commons/lang3/StringUtilsSubstringTest.java
@@ -32,7 +32,6 @@ public class StringUtilsSubstringTest  {
     private static final String FOOBAR = "foobar";
     private static final String SENTENCE = "foo bar baz";
 
-    //-----------------------------------------------------------------------
 
     @Test
     public void testSubstring_StringInt() {
@@ -262,7 +261,6 @@ public class StringUtilsSubstringTest  {
         assertEquals("", StringUtils.substringAfterLast("", 'd'));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testSubstringBetween_StringString() {
         assertNull(StringUtils.substringBetween(null, "tag"));
@@ -351,7 +349,6 @@ public class StringUtilsSubstringTest  {
         assertEquals(0, results.length);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testCountMatches_String() {
         assertEquals(0, StringUtils.countMatches(null, null));
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsTest.java
index 609c0b8d5..2f6d9a706 100644
--- a/src/test/java/org/apache/commons/lang3/StringUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/StringUtilsTest.java
@@ -242,7 +242,6 @@ public class StringUtilsTest {
         assertEquals(str.substring(2), res[1], msg);
     }
 
-    //-----------------------------------------------------------------------
     //Fixed LANG-1463
     @Test
     public void testAbbreviateMarkerWithEmptyString() {
@@ -489,7 +488,6 @@ public class StringUtilsTest {
         assertEquals("'cat'", StringUtils.capitalize("'cat'"));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testCenter_StringInt() {
         assertNull(StringUtils.center(null, -1));
@@ -607,7 +605,6 @@ public class StringUtilsTest {
         }
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testConstructor() {
         assertNotNull(new StringUtils());
@@ -618,7 +615,6 @@ public class StringUtilsTest {
         assertFalse(Modifier.isFinal(StringUtils.class.getModifiers()));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testDefault_String() {
         assertEquals("", StringUtils.defaultString(null));
@@ -787,7 +783,6 @@ public class StringUtilsTest {
         assertEquals("test", StringUtils.deleteWhitespace("\u000Bt  \t\n\u0009e\rs\n\n   \tt"));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testDifference_StringString() {
         assertNull(StringUtils.difference(null, null));
@@ -993,7 +988,6 @@ public class StringUtilsTest {
         assertThrows(IllegalArgumentException.class, () -> StringUtils.getLevenshteinDistance("a", null, 0));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testGetLevenshteinDistance_StringString() {
         assertEquals(0, StringUtils.getLevenshteinDistance("", ""));
@@ -1370,7 +1364,6 @@ public class StringUtilsTest {
         assertEquals(expected, actual);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testJoin_Objects() {
         assertEquals("abc", StringUtils.join("a", "b", "c"));
@@ -1408,7 +1401,6 @@ public class StringUtilsTest {
         assertEquals("121", StringUtils.stripEnd("121.00", ".0"));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testLeftPad_StringInt() {
         assertNull(StringUtils.leftPad(null, 5));
@@ -2228,7 +2220,6 @@ public class StringUtilsTest {
                      StringUtils.replacePattern("Lorem ipsum  dolor   sit", "( +)([a-z]+)", "_$2"));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testReverse_String() {
         assertNull(StringUtils.reverse(null));
@@ -2245,7 +2236,6 @@ public class StringUtilsTest {
         assertEquals("", StringUtils.reverseDelimited("", '.'));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testRightPad_StringInt() {
         assertNull(StringUtils.rightPad(null, 5));
@@ -2282,7 +2272,6 @@ public class StringUtilsTest {
         assertEquals("abc  ", StringUtils.rightPad("abc", 5, ""));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testRotate_StringInt() {
         assertNull(StringUtils.rotate(null, 1));
@@ -3010,7 +2999,6 @@ public class StringUtilsTest {
         assertEquals(expectedString, StringUtils.toString(expectedBytes, encoding));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testTruncate_StringInt() {
         assertNull(StringUtils.truncate(null, 12));
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java
index ee32f0116..c5db103b6 100644
--- a/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java
+++ b/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java
@@ -67,7 +67,6 @@ public class StringUtilsTrimStripTest  {
         assertEquals("", StringUtils.trimToEmpty(null));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testStrip_String() {
         assertNull(StringUtils.strip(null));
diff --git a/src/test/java/org/apache/commons/lang3/builder/CompareToBuilderTest.java b/src/test/java/org/apache/commons/lang3/builder/CompareToBuilderTest.java
index 793940dce..b994596f2 100644
--- a/src/test/java/org/apache/commons/lang3/builder/CompareToBuilderTest.java
+++ b/src/test/java/org/apache/commons/lang3/builder/CompareToBuilderTest.java
@@ -29,7 +29,6 @@ import org.junit.jupiter.api.Test;
  */
 public class CompareToBuilderTest {
 
-    //-----------------------------------------------------------------------
 
     static class TestObject implements Comparable<TestObject> {
         private int a;
diff --git a/src/test/java/org/apache/commons/lang3/builder/EqualsBuilderTest.java b/src/test/java/org/apache/commons/lang3/builder/EqualsBuilderTest.java
index d4610edcb..592684d99 100644
--- a/src/test/java/org/apache/commons/lang3/builder/EqualsBuilderTest.java
+++ b/src/test/java/org/apache/commons/lang3/builder/EqualsBuilderTest.java
@@ -33,7 +33,6 @@ import org.junit.jupiter.api.Test;
  */
 public class EqualsBuilderTest {
 
-    //-----------------------------------------------------------------------
 
     static class TestObject {
         private int a;
diff --git a/src/test/java/org/apache/commons/lang3/builder/HashCodeBuilderAndEqualsBuilderTest.java b/src/test/java/org/apache/commons/lang3/builder/HashCodeBuilderAndEqualsBuilderTest.java
index 53946c481..cadde144e 100644
--- a/src/test/java/org/apache/commons/lang3/builder/HashCodeBuilderAndEqualsBuilderTest.java
+++ b/src/test/java/org/apache/commons/lang3/builder/HashCodeBuilderAndEqualsBuilderTest.java
@@ -27,7 +27,6 @@ import org.junit.jupiter.api.Test;
  */
 public class HashCodeBuilderAndEqualsBuilderTest {
 
-    //-----------------------------------------------------------------------
 
     private void testInteger(final boolean testTransients) {
         final Integer i1 = Integer.valueOf(12345);
diff --git a/src/test/java/org/apache/commons/lang3/builder/ToStringBuilderTest.java b/src/test/java/org/apache/commons/lang3/builder/ToStringBuilderTest.java
index 372c26969..dfe8c49fe 100644
--- a/src/test/java/org/apache/commons/lang3/builder/ToStringBuilderTest.java
+++ b/src/test/java/org/apache/commons/lang3/builder/ToStringBuilderTest.java
@@ -48,7 +48,6 @@ public class ToStringBuilderTest {
         validateNullToStringStyleRegistry();
     }
 
-    //-----------------------------------------------------------------------
 
     @Test
     public void testConstructorEx1() {
diff --git a/src/test/java/org/apache/commons/lang3/builder/ToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/ToStringStyleTest.java
index bb7e36212..52f95e816 100644
--- a/src/test/java/org/apache/commons/lang3/builder/ToStringStyleTest.java
+++ b/src/test/java/org/apache/commons/lang3/builder/ToStringStyleTest.java
@@ -30,7 +30,6 @@ public class ToStringStyleTest {
 
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testSetArrayStart() {
         final ToStringStyle style = new ToStringStyleImpl();
diff --git a/src/test/java/org/apache/commons/lang3/concurrent/ConcurrentUtilsTest.java b/src/test/java/org/apache/commons/lang3/concurrent/ConcurrentUtilsTest.java
index d5d55f5b2..1e20c49b4 100644
--- a/src/test/java/org/apache/commons/lang3/concurrent/ConcurrentUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/concurrent/ConcurrentUtilsTest.java
@@ -269,7 +269,6 @@ public class ConcurrentUtilsTest {
                 null));
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Tests initialize() for a null argument.
      *
@@ -352,7 +351,6 @@ public class ConcurrentUtilsTest {
         EasyMock.verify(init);
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Tests constant future.
      *
@@ -389,7 +387,6 @@ public class ConcurrentUtilsTest {
         assertFalse(test.cancel(false));
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Tests putIfAbsent() if the map contains the key in question.
      */
diff --git a/src/test/java/org/apache/commons/lang3/exception/ExceptionUtilsTest.java b/src/test/java/org/apache/commons/lang3/exception/ExceptionUtilsTest.java
index 797fad985..8a4d65247 100644
--- a/src/test/java/org/apache/commons/lang3/exception/ExceptionUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/exception/ExceptionUtilsTest.java
@@ -124,7 +124,6 @@ public class ExceptionUtilsTest {
 
     private Throwable jdkNoCause;
 
-    //-----------------------------------------------------------------------
 
     private ExceptionWithCause cyclicCause;
 
@@ -142,7 +141,6 @@ public class ExceptionUtilsTest {
         }
     }
 
-    //-----------------------------------------------------------------------
     private Throwable createExceptionWithoutCause() {
         try {
             throw new ExceptionWithoutCause();
@@ -217,7 +215,6 @@ public class ExceptionUtilsTest {
         assertFalse(Modifier.isFinal(ExceptionUtils.class.getModifiers()));
     }
 
-    //-----------------------------------------------------------------------
     @SuppressWarnings("deprecation") // Specifically tests the deprecated methods
     @Test
     public void testGetCause_Throwable() {
@@ -262,7 +259,6 @@ public class ExceptionUtilsTest {
         assertSame(cyclicCause.getCause().getCause(), ExceptionUtils.getRootCause(cyclicCause));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testGetRootCauseStackTrace_Throwable() {
         assertEquals(0, ExceptionUtils.getRootCauseStackTrace(null).length);
@@ -289,7 +285,6 @@ public class ExceptionUtilsTest {
         assertFalse(match);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testGetThrowableCount_Throwable() {
         assertEquals(0, ExceptionUtils.getThrowableCount(null));
@@ -315,7 +310,6 @@ public class ExceptionUtilsTest {
         assertSame(withoutCause, throwables.get(1));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testGetThrowableList_Throwable_null() {
         final List<?> throwables = ExceptionUtils.getThrowableList(null);
@@ -362,7 +356,6 @@ public class ExceptionUtilsTest {
         assertSame(withoutCause, throwables[1]);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testGetThrowables_Throwable_null() {
         assertEquals(0, ExceptionUtils.getThrowables(null).length);
@@ -446,7 +439,6 @@ public class ExceptionUtilsTest {
         assertEquals(-1, ExceptionUtils.indexOfThrowable(withCause, Throwable.class, 0));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testIndexOfType_ThrowableClass() {
         assertEquals(-1, ExceptionUtils.indexOfType(null, null));
@@ -500,7 +492,6 @@ public class ExceptionUtilsTest {
         assertEquals(0, ExceptionUtils.indexOfType(withCause, Throwable.class, 0));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testPrintRootCauseStackTrace_Throwable() {
         ExceptionUtils.printRootCauseStackTrace(null);
@@ -508,7 +499,6 @@ public class ExceptionUtilsTest {
         // internally this method calls stream method anyway
     }
 
-    //-----------------------------------------------------------------------
 
     @Test
     public void testPrintRootCauseStackTrace_ThrowableStream() {
diff --git a/src/test/java/org/apache/commons/lang3/text/StrBuilderAppendInsertTest.java b/src/test/java/org/apache/commons/lang3/text/StrBuilderAppendInsertTest.java
index 8ae0b90bc..0e4122d36 100644
--- a/src/test/java/org/apache/commons/lang3/text/StrBuilderAppendInsertTest.java
+++ b/src/test/java/org/apache/commons/lang3/text/StrBuilderAppendInsertTest.java
@@ -45,7 +45,6 @@ public class StrBuilderAppendInsertTest {
         }
     };
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendNewLine() {
         StrBuilder sb = new StrBuilder("---");
@@ -57,7 +56,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("---#" + SEP, sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendWithNullText() {
         final StrBuilder sb = new StrBuilder();
@@ -89,7 +87,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("NULLNULLfooNULLbarNULLbaz", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_Object() {
         final StrBuilder sb = new StrBuilder();
@@ -118,7 +115,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foobazyesSeqbld", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_StringBuilder() {
         StrBuilder sb = new StrBuilder();
@@ -136,7 +132,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foobar", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_String() {
         StrBuilder sb = new StrBuilder();
@@ -154,7 +149,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foobar", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_String_int_int() {
         StrBuilder sb = new StrBuilder();
@@ -206,7 +200,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foobarard", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_StringBuilder_int_int() {
         StrBuilder sb = new StrBuilder();
@@ -258,7 +251,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foobarard", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_StringBuffer() {
         StrBuilder sb = new StrBuilder();
@@ -276,7 +268,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foobar", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_StringBuffer_int_int() {
         StrBuilder sb = new StrBuilder();
@@ -325,7 +316,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foobar", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_StrBuilder() {
         StrBuilder sb = new StrBuilder();
@@ -343,7 +333,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foobar", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_StrBuilder_int_int() {
         StrBuilder sb = new StrBuilder();
@@ -392,7 +381,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foobar", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_CharArray() {
         StrBuilder sb = new StrBuilder();
@@ -407,7 +395,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foo", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_CharArray_int_int() {
         StrBuilder sb = new StrBuilder();
@@ -456,7 +443,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foobar", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_Boolean() {
         final StrBuilder sb = new StrBuilder();
@@ -470,7 +456,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("truefalse!", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_PrimitiveNumber() {
         final StrBuilder sb = new StrBuilder();
@@ -487,7 +472,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("012.34.5", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_FormattedString() {
         final int[] count = new int[2];
@@ -511,7 +495,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals(1, count[1]);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_Object() {
         final StrBuilder sb = new StrBuilder();
@@ -525,7 +508,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals(SEP + "foo" + SEP + "6" + SEP, sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_String() {
         final int[] count = new int[2];
@@ -549,7 +531,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals(1, count[1]);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_String_int_int() {
         final int[] count = new int[2];
@@ -573,7 +554,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals(1, count[1]);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_StringBuffer() {
         final int[] count = new int[2];
@@ -597,7 +577,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals(1, count[1]);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_StringBuilder() {
         final int[] count = new int[2];
@@ -621,7 +600,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals(1, count[1]);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_StringBuffer_int_int() {
         final int[] count = new int[2];
@@ -645,7 +623,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals(1, count[1]);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_StringBuilder_int_int() {
         final int[] count = new int[2];
@@ -669,7 +646,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals(1, count[1]);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_StrBuilder() {
         final int[] count = new int[2];
@@ -693,7 +669,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals(1, count[1]);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_StrBuilder_int_int() {
         final int[] count = new int[2];
@@ -717,7 +692,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals(1, count[1]);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_CharArray() {
         final int[] count = new int[2];
@@ -741,7 +715,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals(1, count[1]);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_CharArray_int_int() {
         final int[] count = new int[2];
@@ -765,7 +738,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals(1, count[1]);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_Boolean() {
         final StrBuilder sb = new StrBuilder();
@@ -777,7 +749,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("false" + SEP, sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_PrimitiveNumber() {
         final StrBuilder sb = new StrBuilder();
@@ -797,7 +768,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("4.5" + SEP, sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendPadding() {
         final StrBuilder sb = new StrBuilder();
@@ -819,7 +789,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foo-----------------", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendFixedWidthPadLeft() {
         final StrBuilder sb = new StrBuilder();
@@ -858,7 +827,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("-null", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendFixedWidthPadLeft_int() {
         final StrBuilder sb = new StrBuilder();
@@ -892,7 +860,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("-------123", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendFixedWidthPadRight() {
         final StrBuilder sb = new StrBuilder();
@@ -939,7 +906,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("f", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendFixedWidthPadRight_int() {
         final StrBuilder sb = new StrBuilder();
@@ -973,7 +939,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("123-------", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_FormattedString() {
         StrBuilder sb;
@@ -998,7 +963,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals(expected, sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendAll_Array() {
         final StrBuilder sb = new StrBuilder();
@@ -1018,7 +982,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foobarbaz", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendAll_Collection() {
         final StrBuilder sb = new StrBuilder();
@@ -1034,7 +997,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foobarbaz", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendAll_Iterator() {
         final StrBuilder sb = new StrBuilder();
@@ -1050,7 +1012,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foobarbaz", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendWithSeparators_Array() {
         final StrBuilder sb = new StrBuilder();
@@ -1074,7 +1035,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foo,,baz", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendWithSeparators_Collection() {
         final StrBuilder sb = new StrBuilder();
@@ -1098,7 +1058,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foo,,baz", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendWithSeparators_Iterator() {
         final StrBuilder sb = new StrBuilder();
@@ -1122,7 +1081,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foo,,baz", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendWithSeparatorsWithNullText() {
         final StrBuilder sb = new StrBuilder();
@@ -1135,7 +1093,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foo,null,baz", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendSeparator_String() {
         final StrBuilder sb = new StrBuilder();
@@ -1147,7 +1104,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foo,", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendSeparator_String_String() {
         final StrBuilder sb = new StrBuilder();
@@ -1170,7 +1126,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals(startSeparator + foo + standardSeparator, sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendSeparator_char() {
         final StrBuilder sb = new StrBuilder();
@@ -1195,7 +1150,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals(String.valueOf(startSeparator) + foo + standardSeparator, sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendSeparator_String_int() {
         final StrBuilder sb = new StrBuilder();
@@ -1210,7 +1164,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foo,", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendSeparator_char_int() {
         final StrBuilder sb = new StrBuilder();
@@ -1225,7 +1178,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("foo,", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testInsert() {
 
@@ -1444,7 +1396,6 @@ public class StrBuilderAppendInsertTest {
         assertEquals("4.5barbaz", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testInsertWithNullText() {
         final StrBuilder sb = new StrBuilder();
diff --git a/src/test/java/org/apache/commons/lang3/text/StrBuilderTest.java b/src/test/java/org/apache/commons/lang3/text/StrBuilderTest.java
index ef7c567e4..5c454e884 100644
--- a/src/test/java/org/apache/commons/lang3/text/StrBuilderTest.java
+++ b/src/test/java/org/apache/commons/lang3/text/StrBuilderTest.java
@@ -44,7 +44,6 @@ import org.junit.jupiter.api.Test;
 @Deprecated
 public class StrBuilderTest {
 
-    //-----------------------------------------------------------------------
     @Test
     public void testConstructors() {
         final StrBuilder sb0 = new StrBuilder();
@@ -88,7 +87,6 @@ public class StrBuilderTest {
         assertEquals(3, sb7.size());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testChaining() {
         final StrBuilder sb = new StrBuilder();
@@ -103,7 +101,6 @@ public class StrBuilderTest {
         assertSame(sb, sb.trim());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testReadFromReader() throws Exception {
         String s = "";
@@ -181,7 +178,6 @@ public class StrBuilderTest {
         }
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testGetSetNewLineText() {
         final StrBuilder sb = new StrBuilder();
@@ -197,7 +193,6 @@ public class StrBuilderTest {
         assertNull(sb.getNewLineText());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testGetSetNullText() {
         final StrBuilder sb = new StrBuilder();
@@ -216,7 +211,6 @@ public class StrBuilderTest {
         assertNull(sb.getNullText());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testCapacityAndLength() {
         final StrBuilder sb = new StrBuilder();
@@ -299,7 +293,6 @@ public class StrBuilderTest {
         assertTrue(sb.isEmpty());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testLength() {
         final StrBuilder sb = new StrBuilder();
@@ -326,7 +319,6 @@ public class StrBuilderTest {
                 "setLength(-1) expected StringIndexOutOfBoundsException");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testCapacity() {
         final StrBuilder sb = new StrBuilder();
@@ -361,7 +353,6 @@ public class StrBuilderTest {
         assertEquals(10, sb.capacity());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testSize() {
         final StrBuilder sb = new StrBuilder();
@@ -392,7 +383,6 @@ public class StrBuilderTest {
         assertTrue(sb.buffer.length >= 5);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testCharAt() {
         final StrBuilder sb = new StrBuilder();
@@ -410,7 +400,6 @@ public class StrBuilderTest {
                 IndexOutOfBoundsException.class, () -> sb.charAt(3), "charAt(3) expected IndexOutOfBoundsException");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testSetCharAt() {
         final StrBuilder sb = new StrBuilder();
@@ -433,7 +422,6 @@ public class StrBuilderTest {
         assertEquals("bar", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testDeleteCharAt() {
         final StrBuilder sb = new StrBuilder("abc");
@@ -443,7 +431,6 @@ public class StrBuilderTest {
         assertThrows(IndexOutOfBoundsException.class, () -> sb.deleteCharAt(1000));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testToCharArray() {
         final StrBuilder sb = new StrBuilder();
@@ -534,7 +521,6 @@ public class StrBuilderTest {
         assertThrows(IndexOutOfBoundsException.class, () -> sb.getChars(4, 2, b, 0));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testDeleteIntInt() {
         final StrBuilder sb = new StrBuilder("abc");
@@ -552,7 +538,6 @@ public class StrBuilderTest {
         assertThrows(IndexOutOfBoundsException.class, () -> new StrBuilder("anything").delete(2, 1));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testDeleteAll_char() {
         StrBuilder sb = new StrBuilder("abcbccba");
@@ -702,7 +687,6 @@ public class StrBuilderTest {
         assertThrows(IndexOutOfBoundsException.class, () -> sb2.replace(-1, 1, "anything"));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testReplaceAll_char_char() {
         final StrBuilder sb = new StrBuilder("abcbccba");
@@ -718,7 +702,6 @@ public class StrBuilderTest {
         assertEquals("defeffed", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testReplaceFirst_char_char() {
         final StrBuilder sb = new StrBuilder("abcbccba");
@@ -734,7 +717,6 @@ public class StrBuilderTest {
         assertEquals("defbccba", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testReplaceAll_String_String() {
         StrBuilder sb = new StrBuilder("abcbccba");
@@ -795,7 +777,6 @@ public class StrBuilderTest {
         assertEquals("xbxb", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testReplaceAll_StrMatcher_String() {
         StrBuilder sb = new StrBuilder("abcbccba");
@@ -868,7 +849,6 @@ public class StrBuilderTest {
         assertEquals("***-A2A3-A4", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testReplace_StrMatcher_String_int_int_int_VaryMatcher() {
         StrBuilder sb = new StrBuilder("abcbccba");
@@ -1056,7 +1036,6 @@ public class StrBuilderTest {
         assertEquals("-x--y-", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testReverse() {
         final StrBuilder sb = new StrBuilder();
@@ -1067,7 +1046,6 @@ public class StrBuilderTest {
         assertEquals("true", sb.reverse().toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testTrim() {
         final StrBuilder sb = new StrBuilder();
@@ -1089,7 +1067,6 @@ public class StrBuilderTest {
         assertEquals("a b c", sb.trim().toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testStartsWith() {
         final StrBuilder sb = new StrBuilder();
@@ -1120,7 +1097,6 @@ public class StrBuilderTest {
         assertFalse(sb.endsWith("abc "));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testSubSequenceIntInt() {
        final StrBuilder sb = new StrBuilder ("hello goodbye");
@@ -1558,7 +1534,6 @@ public class StrBuilderTest {
         }
     };
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAsTokenizer() {
         // from Javadoc
@@ -1654,7 +1629,6 @@ public class StrBuilderTest {
         assertEquals(9, r.read(array, 0, 30));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAsWriter() throws Exception {
         final StrBuilder sb = new StrBuilder("base");
@@ -1689,7 +1663,6 @@ public class StrBuilderTest {
         assertEquals("based", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testEqualsIgnoreCase() {
         final StrBuilder sb1 = new StrBuilder();
@@ -1713,7 +1686,6 @@ public class StrBuilderTest {
         assertTrue(sb1.equalsIgnoreCase(sb2));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testEquals() {
         final StrBuilder sb1 = new StrBuilder();
@@ -1746,7 +1718,6 @@ public class StrBuilderTest {
         assertFalse(sb.equals(other));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testHashCode() {
         final StrBuilder sb = new StrBuilder();
@@ -1762,14 +1733,12 @@ public class StrBuilderTest {
         assertEquals(hc2a, hc2b);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testToString() {
         final StrBuilder sb = new StrBuilder("abc");
         assertEquals("abc", sb.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testToStringBuffer() {
         final StrBuilder sb = new StrBuilder();
@@ -1779,7 +1748,6 @@ public class StrBuilderTest {
         assertEquals(new StringBuffer("junit").toString(), sb.toStringBuffer().toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testToStringBuilder() {
         final StrBuilder sb = new StrBuilder();
@@ -1789,7 +1757,6 @@ public class StrBuilderTest {
         assertEquals(new StringBuilder("junit").toString(), sb.toStringBuilder().toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testLang294() {
         final StrBuilder sb = new StrBuilder("\n%BLAH%\nDo more stuff\neven more stuff\n%BLAH%\n");
@@ -1804,7 +1771,6 @@ public class StrBuilderTest {
         assertEquals(-1, sb.indexOf("three"));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testLang295() {
         final StrBuilder sb = new StrBuilder("onetwothree");
@@ -1813,7 +1779,6 @@ public class StrBuilderTest {
         assertEquals(-1, sb.indexOf('h'), "The indexOf(char) method is looking beyond the end of the string");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testLang412Right() {
         final StrBuilder sb = new StrBuilder();
@@ -1834,7 +1799,6 @@ public class StrBuilderTest {
         assertEquals(sb.toString(), sb.build());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendCharBuffer() {
         final StrBuilder sb1 = new StrBuilder();
@@ -1849,7 +1813,6 @@ public class StrBuilderTest {
         assertEquals("12345678", sb2.toString());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendToWriter() throws Exception {
         final StrBuilder sb = new StrBuilder("1234567890");
diff --git a/src/test/java/org/apache/commons/lang3/text/StrLookupTest.java b/src/test/java/org/apache/commons/lang3/text/StrLookupTest.java
index d256f21e4..f00da7697 100644
--- a/src/test/java/org/apache/commons/lang3/text/StrLookupTest.java
+++ b/src/test/java/org/apache/commons/lang3/text/StrLookupTest.java
@@ -33,7 +33,6 @@ import org.junit.jupiter.api.Test;
 @Deprecated
 public class StrLookupTest  {
 
-    //-----------------------------------------------------------------------
     @Test
     public void testNoneLookup() {
         assertNull(StrLookup.noneLookup().lookup(null));
diff --git a/src/test/java/org/apache/commons/lang3/text/StrMatcherTest.java b/src/test/java/org/apache/commons/lang3/text/StrMatcherTest.java
index f940ac2e7..0d2564f21 100644
--- a/src/test/java/org/apache/commons/lang3/text/StrMatcherTest.java
+++ b/src/test/java/org/apache/commons/lang3/text/StrMatcherTest.java
@@ -34,7 +34,6 @@ public class StrMatcherTest  {
     private static final char[] BUFFER2 = "abcdef".toCharArray();
 
 
-    //-----------------------------------------------------------------------
     @Test
     public void testCommaMatcher() {
         final StrMatcher matcher = StrMatcher.commaMatcher();
@@ -44,7 +43,6 @@ public class StrMatcherTest  {
         assertEquals(0, matcher.isMatch(BUFFER1, 2));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testTabMatcher() {
         final StrMatcher matcher = StrMatcher.tabMatcher();
@@ -54,7 +52,6 @@ public class StrMatcherTest  {
         assertEquals(0, matcher.isMatch(BUFFER1, 4));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testSpaceMatcher() {
         final StrMatcher matcher = StrMatcher.spaceMatcher();
@@ -64,7 +61,6 @@ public class StrMatcherTest  {
         assertEquals(0, matcher.isMatch(BUFFER1, 6));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testSplitMatcher() {
         final StrMatcher matcher = StrMatcher.splitMatcher();
@@ -80,7 +76,6 @@ public class StrMatcherTest  {
         assertEquals(0, matcher.isMatch(BUFFER1, 10));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testTrimMatcher() {
         final StrMatcher matcher = StrMatcher.trimMatcher();
@@ -96,7 +91,6 @@ public class StrMatcherTest  {
         assertEquals(1, matcher.isMatch(BUFFER1, 10));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testSingleQuoteMatcher() {
         final StrMatcher matcher = StrMatcher.singleQuoteMatcher();
@@ -106,7 +100,6 @@ public class StrMatcherTest  {
         assertEquals(0, matcher.isMatch(BUFFER1, 12));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testDoubleQuoteMatcher() {
         final StrMatcher matcher = StrMatcher.doubleQuoteMatcher();
@@ -115,7 +108,6 @@ public class StrMatcherTest  {
         assertEquals(1, matcher.isMatch(BUFFER1, 12));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testQuoteMatcher() {
         final StrMatcher matcher = StrMatcher.quoteMatcher();
@@ -125,7 +117,6 @@ public class StrMatcherTest  {
         assertEquals(1, matcher.isMatch(BUFFER1, 12));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testNoneMatcher() {
         final StrMatcher matcher = StrMatcher.noneMatcher();
@@ -145,7 +136,6 @@ public class StrMatcherTest  {
         assertEquals(0, matcher.isMatch(BUFFER1, 12));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testCharMatcher_char() {
         final StrMatcher matcher = StrMatcher.charMatcher('c');
@@ -157,7 +147,6 @@ public class StrMatcherTest  {
         assertEquals(0, matcher.isMatch(BUFFER2, 5));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testCharSetMatcher_String() {
         final StrMatcher matcher = StrMatcher.charSetMatcher("ace");
@@ -172,7 +161,6 @@ public class StrMatcherTest  {
         assertTrue(StrMatcher.charSetMatcher("a") instanceof StrMatcher.CharMatcher);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testCharSetMatcher_charArray() {
         final StrMatcher matcher = StrMatcher.charSetMatcher("ace".toCharArray());
@@ -187,7 +175,6 @@ public class StrMatcherTest  {
         assertTrue(StrMatcher.charSetMatcher("a".toCharArray()) instanceof StrMatcher.CharMatcher);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testStringMatcher_String() {
         final StrMatcher matcher = StrMatcher.stringMatcher("bc");
@@ -201,7 +188,6 @@ public class StrMatcherTest  {
         assertSame(StrMatcher.noneMatcher(), StrMatcher.stringMatcher(null));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testMatcherIndices() {
         // remember that the API contract is tight for the isMatch() method
diff --git a/src/test/java/org/apache/commons/lang3/text/StrSubstitutorTest.java b/src/test/java/org/apache/commons/lang3/text/StrSubstitutorTest.java
index a5879b680..0321e738f 100644
--- a/src/test/java/org/apache/commons/lang3/text/StrSubstitutorTest.java
+++ b/src/test/java/org/apache/commons/lang3/text/StrSubstitutorTest.java
@@ -53,7 +53,6 @@ public class StrSubstitutorTest {
         values = null;
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Tests simple key replace.
      */
@@ -392,7 +391,6 @@ public class StrSubstitutorTest {
                 sub.replace("The ${animal} jumps over the lazy ${target}. ${undefined.number!1234567890}."));
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Tests protected.
      */
@@ -415,7 +413,6 @@ public class StrSubstitutorTest {
         assertEquals("Hi jakarta!", builder.toString());
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Tests constructor.
      */
@@ -449,7 +446,6 @@ public class StrSubstitutorTest {
         assertEquals("Hi < commons", sub.replace("Hi !< <name2||commons>"));
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Tests get set.
      */
@@ -527,7 +523,6 @@ public class StrSubstitutorTest {
         assertNull(sub.getValueDelimiterMatcher());
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Tests static.
      */
@@ -615,7 +610,6 @@ public class StrSubstitutorTest {
         assertEquals("value $${escaped}", sub.replace(org));
     }
 
-    //-----------------------------------------------------------------------
     private void doTestReplace(final String expectedResult, final String replaceTemplate, final boolean substring) {
         final String expectedShortResult = expectedResult.substring(1, expectedResult.length() - 1);
         final StrSubstitutor sub = new StrSubstitutor(values);
diff --git a/src/test/java/org/apache/commons/lang3/text/StrTokenizerTest.java b/src/test/java/org/apache/commons/lang3/text/StrTokenizerTest.java
index 08ffb0125..615a4b915 100644
--- a/src/test/java/org/apache/commons/lang3/text/StrTokenizerTest.java
+++ b/src/test/java/org/apache/commons/lang3/text/StrTokenizerTest.java
@@ -497,7 +497,6 @@ public class StrTokenizerTest {
         assertFalse(tok.hasNext());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testListArray() {
         final String input = "a  b c";
@@ -509,7 +508,6 @@ public class StrTokenizerTest {
         assertEquals(3, list.size());
     }
 
-    //-----------------------------------------------------------------------
     private void testCSV(final String data) {
         this.testXSVAbc(StrTokenizer.getCSVInstance(data));
         this.testXSVAbc(StrTokenizer.getCSVInstance(data.toCharArray()));
@@ -555,7 +553,6 @@ public class StrTokenizerTest {
         assertNull(tok.getContent());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testChaining() {
         final StrTokenizer tok = new StrTokenizer();
@@ -634,7 +631,6 @@ public class StrTokenizerTest {
         assertFalse(tok.hasNext());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testConstructor_String_char() {
         StrTokenizer tok = new StrTokenizer("a b", ' ');
@@ -650,7 +646,6 @@ public class StrTokenizerTest {
         assertFalse(tok.hasNext());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testConstructor_String_char_char() {
         StrTokenizer tok = new StrTokenizer("a b", ' ', '"');
@@ -667,7 +662,6 @@ public class StrTokenizerTest {
         assertFalse(tok.hasNext());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testConstructor_charArray() {
         StrTokenizer tok = new StrTokenizer("a b".toCharArray());
@@ -682,7 +676,6 @@ public class StrTokenizerTest {
         assertFalse(tok.hasNext());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testConstructor_charArray_char() {
         StrTokenizer tok = new StrTokenizer("a b".toCharArray(), ' ');
@@ -698,7 +691,6 @@ public class StrTokenizerTest {
         assertFalse(tok.hasNext());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testConstructor_charArray_char_char() {
         StrTokenizer tok = new StrTokenizer("a b".toCharArray(), ' ', '"');
@@ -715,7 +707,6 @@ public class StrTokenizerTest {
         assertFalse(tok.hasNext());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testReset() {
         final StrTokenizer tok = new StrTokenizer("a b c");
@@ -731,7 +722,6 @@ public class StrTokenizerTest {
         assertFalse(tok.hasNext());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testReset_String() {
         final StrTokenizer tok = new StrTokenizer("x x x");
@@ -744,7 +734,6 @@ public class StrTokenizerTest {
         assertFalse(tok.hasNext());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testReset_charArray() {
         final StrTokenizer tok = new StrTokenizer("x x x");
@@ -758,7 +747,6 @@ public class StrTokenizerTest {
         assertFalse(tok.hasNext());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testTSV() {
         this.testXSVAbc(StrTokenizer.getTSVInstance(TSV_SIMPLE_FIXTURE));
@@ -823,7 +811,6 @@ public class StrTokenizerTest {
         assertFalse(tkn.hasNext());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testTokenizeSubclassInputChange() {
         final StrTokenizer tkn = new StrTokenizer("a b c d e") {
@@ -836,7 +823,6 @@ public class StrTokenizerTest {
         assertEquals("y", tkn.next());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testTokenizeSubclassOutputChange() {
         final StrTokenizer tkn = new StrTokenizer("a b c") {
@@ -852,7 +838,6 @@ public class StrTokenizerTest {
         assertEquals("a", tkn.next());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testToString() {
         final StrTokenizer tkn = new StrTokenizer("a b c d e");
diff --git a/src/test/java/org/apache/commons/lang3/text/WordUtilsTest.java b/src/test/java/org/apache/commons/lang3/text/WordUtilsTest.java
index 6fe861579..3156b9db5 100644
--- a/src/test/java/org/apache/commons/lang3/text/WordUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/text/WordUtilsTest.java
@@ -33,7 +33,6 @@ import org.junit.jupiter.api.Test;
 @Deprecated
 public class WordUtilsTest {
 
-    //-----------------------------------------------------------------------
     @Test
     public void testConstructor() {
         assertNotNull(new WordUtils());
@@ -44,7 +43,6 @@ public class WordUtilsTest {
         assertFalse(Modifier.isFinal(WordUtils.class.getModifiers()));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testWrap_StringInt() {
         assertNull(WordUtils.wrap(null, 20));
@@ -182,7 +180,6 @@ public class WordUtilsTest {
         assertEquals(expected, WordUtils.wrap(input, 15, "\n", true, "/"));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testCapitalize_String() {
         assertNull(WordUtils.capitalize(null));
@@ -299,7 +296,6 @@ public class WordUtilsTest {
         assertEquals("i aM.FINE", WordUtils.uncapitalize("I AM.FINE", null) );
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testInitials_String() {
         assertNull(WordUtils.initials(null));
diff --git a/src/test/java/org/apache/commons/lang3/time/DateFormatUtilsTest.java b/src/test/java/org/apache/commons/lang3/time/DateFormatUtilsTest.java
index cff1aac5e..0c78bb488 100644
--- a/src/test/java/org/apache/commons/lang3/time/DateFormatUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/time/DateFormatUtilsTest.java
@@ -56,7 +56,6 @@ public class DateFormatUtilsTest {
         return cal;
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testConstructor() {
         assertNotNull(new DateFormatUtils());
@@ -81,7 +80,6 @@ public class DateFormatUtilsTest {
         testUTC("2002-02-23T09:11:12Z", DateFormatUtils.ISO_DATETIME_TIME_ZONE_FORMAT.getPattern());
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testFormat() {
         final Calendar c = Calendar.getInstance(FastTimeZone.getGmtTimeZone());
@@ -105,7 +103,6 @@ public class DateFormatUtilsTest {
         assertEquals(buffer.toString(), DateFormatUtils.format(c.getTime().getTime(), "yyyyMdH", Locale.US));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testFormatCalendar() {
         final Calendar c = Calendar.getInstance(FastTimeZone.getGmtTimeZone());
diff --git a/src/test/java/org/apache/commons/lang3/time/DateUtilsTest.java b/src/test/java/org/apache/commons/lang3/time/DateUtilsTest.java
index 311956165..7247122f9 100644
--- a/src/test/java/org/apache/commons/lang3/time/DateUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/time/DateUtilsTest.java
@@ -144,7 +144,6 @@ public class DateUtilsTest {
 
     private TimeZone defaultZone = null;
 
-    //-----------------------------------------------------------------------
     private void assertDate(final Date date, final int year, final int month, final int day, final int hour, final int min, final int sec, final int mil) {
         final GregorianCalendar cal = new GregorianCalendar();
         cal.setTime(date);
@@ -215,7 +214,6 @@ public class DateUtilsTest {
         }
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAddDays() throws Exception {
         Date result = DateUtils.addDays(BASE_DATE, 0);
@@ -234,7 +232,6 @@ public class DateUtilsTest {
         assertDate(result, 2000, 6, 4, 4, 3, 2, 1);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAddHours() throws Exception {
         Date result = DateUtils.addHours(BASE_DATE, 0);
@@ -253,7 +250,6 @@ public class DateUtilsTest {
         assertDate(result, 2000, 6, 5, 3, 3, 2, 1);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAddMilliseconds() throws Exception {
         Date result = DateUtils.addMilliseconds(BASE_DATE, 0);
@@ -272,7 +268,6 @@ public class DateUtilsTest {
         assertDate(result, 2000, 6, 5, 4, 3, 2, 0);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAddMinutes() throws Exception {
         Date result = DateUtils.addMinutes(BASE_DATE, 0);
@@ -291,7 +286,6 @@ public class DateUtilsTest {
         assertDate(result, 2000, 6, 5, 4, 2, 2, 1);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAddMonths() throws Exception {
         Date result = DateUtils.addMonths(BASE_DATE, 0);
@@ -310,7 +304,6 @@ public class DateUtilsTest {
         assertDate(result, 2000, 5, 5, 4, 3, 2, 1);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAddSeconds() throws Exception {
         Date result = DateUtils.addSeconds(BASE_DATE, 0);
@@ -329,7 +322,6 @@ public class DateUtilsTest {
         assertDate(result, 2000, 6, 5, 4, 3, 1, 1);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAddWeeks() throws Exception {
         Date result = DateUtils.addWeeks(BASE_DATE, 0);
@@ -348,7 +340,6 @@ public class DateUtilsTest {
         assertDate(result, 2000, 5, 28, 4, 3, 2, 1);   // june
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAddYears() throws Exception {
         Date result = DateUtils.addYears(BASE_DATE, 0);
@@ -597,7 +588,6 @@ public class DateUtilsTest {
         assertEquals(0, cal.get(Calendar.HOUR));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testConstructor() {
         assertNotNull(new DateUtils());
@@ -608,7 +598,6 @@ public class DateUtilsTest {
         assertFalse(Modifier.isFinal(DateUtils.class.getModifiers()));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testIsSameDay_Cal() {
         final GregorianCalendar cala = new GregorianCalendar(2004, 6, 9, 13, 45);
@@ -637,7 +626,6 @@ public class DateUtilsTest {
         assertThrows(IllegalArgumentException.class, () -> DateUtils.isSameDay((Calendar) null, null));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testIsSameDay_Date() {
         Date datea = new GregorianCalendar(2004, 6, 9, 13, 45).getTime();
@@ -666,7 +654,6 @@ public class DateUtilsTest {
         assertThrows(IllegalArgumentException.class, () -> DateUtils.isSameDay((Date) null, null));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testIsSameInstant_Cal() {
         final GregorianCalendar cala = new GregorianCalendar(TimeZone.getTimeZone("GMT+1"));
@@ -696,7 +683,6 @@ public class DateUtilsTest {
         assertThrows(IllegalArgumentException.class, () -> DateUtils.isSameInstant((Calendar) null, null));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testIsSameInstant_Date() {
         Date datea = new GregorianCalendar(2004, 6, 9, 13, 45).getTime();
@@ -725,7 +711,6 @@ public class DateUtilsTest {
         assertThrows(IllegalArgumentException.class, () -> DateUtils.isSameInstant((Date) null, null));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testIsSameLocalTime_Cal() {
         final GregorianCalendar cala = new GregorianCalendar(TimeZone.getTimeZone("GMT+1"));
@@ -867,7 +852,6 @@ public class DateUtilsTest {
         assertThrows(IllegalArgumentException.class, () -> DateUtils.parseDate("19721203", (String[]) null));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testParseDate() throws Exception {
         final GregorianCalendar cal = new GregorianCalendar(1972, 11, 3);
@@ -916,7 +900,6 @@ public class DateUtilsTest {
         assertThrows(ParseException.class, () -> DateUtils.parseDateStrictly(dateStr, parsers));
     }
 
-    //-----------------------------------------------------------------------
     /**
      * Tests various values with the round method
      *
@@ -1322,14 +1305,12 @@ public class DateUtilsTest {
         assertDate(result, 2005, 6, 5, 4, 3, 2, 1);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testToCalendar() {
         assertEquals(date1, DateUtils.toCalendar(date1).getTime(), "Failed to convert to a Calendar and back");
         assertThrows(NullPointerException.class, () -> DateUtils.toCalendar(null));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testToCalendarWithDateAndTimeZoneNotNull() {
         final Calendar c = DateUtils.toCalendar(date2, defaultZone);
@@ -1337,19 +1318,16 @@ public class DateUtilsTest {
         assertEquals(defaultZone, c.getTimeZone(), "Convert Date and TimeZone to a Calendar, but failed to get the TimeZone back");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testToCalendarWithDateAndTimeZoneNull() {
         assertThrows(NullPointerException.class, () -> DateUtils.toCalendar(null, null));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testToCalendarWithDateNull() {
         assertThrows(NullPointerException.class, () -> DateUtils.toCalendar(null, zone));
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testToCalendarWithTimeZoneNull() {
         assertThrows(NullPointerException.class, () -> DateUtils.toCalendar(date1, null));