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 2020/07/02 20:16:25 UTC

[commons-text] branch master updated: Use mocks instead of custom code to verify API calls.

This is an automated email from the ASF dual-hosted git repository.

ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-text.git


The following commit(s) were added to refs/heads/master by this push:
     new 4fadc3c  Use mocks instead of custom code to verify API calls.
4fadc3c is described below

commit 4fadc3c508afda0b20d26d0a5031bf241e4e4d1d
Author: Gary Gregory <ga...@gmail.com>
AuthorDate: Thu Jul 2 16:16:18 2020 -0400

    Use mocks instead of custom code to verify API calls.
---
 .../text/TextStringBuilderAppendInsertTest.java    | 389 ++++++---------------
 1 file changed, 103 insertions(+), 286 deletions(-)

diff --git a/src/test/java/org/apache/commons/text/TextStringBuilderAppendInsertTest.java b/src/test/java/org/apache/commons/text/TextStringBuilderAppendInsertTest.java
index 386fddd..9f6fe32 100644
--- a/src/test/java/org/apache/commons/text/TextStringBuilderAppendInsertTest.java
+++ b/src/test/java/org/apache/commons/text/TextStringBuilderAppendInsertTest.java
@@ -20,6 +20,12 @@ package org.apache.commons.text;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.fail;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
 import java.text.DecimalFormatSymbols;
 import java.util.Arrays;
@@ -46,7 +52,6 @@ public class TextStringBuilderAppendInsertTest {
         }
     };
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_Boolean() {
         final TextStringBuilder sb = new TextStringBuilder();
@@ -60,7 +65,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("truefalse!");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_CharArray() {
         TextStringBuilder sb = new TextStringBuilder();
@@ -71,11 +75,10 @@ public class TextStringBuilderAppendInsertTest {
         sb.append(ArrayUtils.EMPTY_CHAR_ARRAY);
         assertThat(sb.toString()).isEqualTo("");
 
-        sb.append(new char[]{'f', 'o', 'o'});
+        sb.append(new char[] {'f', 'o', 'o'});
         assertThat(sb.toString()).isEqualTo("foo");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_CharArray_int_int() {
         TextStringBuilder sb = new TextStringBuilder();
@@ -83,59 +86,58 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("NULL");
 
         sb = new TextStringBuilder();
-        sb.append(new char[]{'f', 'o', 'o'}, 0, 3);
+        sb.append(new char[] {'f', 'o', 'o'}, 0, 3);
         assertThat(sb.toString()).isEqualTo("foo");
 
         try {
-            sb.append(new char[]{'b', 'a', 'r'}, -1, 1);
+            sb.append(new char[] {'b', 'a', 'r'}, -1, 1);
             fail("append(char[], -1,) expected IndexOutOfBoundsException");
         } catch (final IndexOutOfBoundsException e) {
             // expected
         }
 
         try {
-            sb.append(new char[]{'b', 'a', 'r'}, 3, 1);
+            sb.append(new char[] {'b', 'a', 'r'}, 3, 1);
             fail("append(char[], 3,) expected IndexOutOfBoundsException");
         } catch (final IndexOutOfBoundsException e) {
             // expected
         }
 
         try {
-            sb.append(new char[]{'b', 'a', 'r'}, 1, -1);
+            sb.append(new char[] {'b', 'a', 'r'}, 1, -1);
             fail("append(char[],, -1) expected IndexOutOfBoundsException");
         } catch (final IndexOutOfBoundsException e) {
             // expected
         }
 
         try {
-            sb.append(new char[]{'b', 'a', 'r'}, 1, 3);
+            sb.append(new char[] {'b', 'a', 'r'}, 1, 3);
             fail("append(char[], 1, 3) expected IndexOutOfBoundsException");
         } catch (final IndexOutOfBoundsException e) {
             // expected
         }
 
         try {
-            sb.append(new char[]{'b', 'a', 'r'}, -1, 3);
+            sb.append(new char[] {'b', 'a', 'r'}, -1, 3);
             fail("append(char[], -1, 3) expected IndexOutOfBoundsException");
         } catch (final IndexOutOfBoundsException e) {
             // expected
         }
 
         try {
-            sb.append(new char[]{'b', 'a', 'r'}, 4, 0);
+            sb.append(new char[] {'b', 'a', 'r'}, 4, 0);
             fail("append(char[], 4, 0) expected IndexOutOfBoundsException");
         } catch (final IndexOutOfBoundsException e) {
             // expected
         }
 
-        sb.append(new char[]{'b', 'a', 'r'}, 3, 0);
+        sb.append(new char[] {'b', 'a', 'r'}, 3, 0);
         assertThat(sb.toString()).isEqualTo("foo");
 
-        sb.append(new char[]{'a', 'b', 'c', 'b', 'a', 'r', 'd', 'e', 'f'}, 3, 3);
+        sb.append(new char[] {'a', 'b', 'c', 'b', 'a', 'r', 'd', 'e', 'f'}, 3, 3);
         assertThat(sb.toString()).isEqualTo("foobar");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_FormattedString() {
         TextStringBuilder sb;
@@ -160,7 +162,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo(expected);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_Object() {
         final TextStringBuilder sb = new TextStringBuilder();
@@ -189,7 +190,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("foobazyesSeqbld");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_PrimitiveNumber() {
         final TextStringBuilder sb = new TextStringBuilder();
@@ -206,7 +206,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("012.34.5");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_String() {
         TextStringBuilder sb = new TextStringBuilder();
@@ -224,7 +223,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("foobar");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_String_int_int() {
         TextStringBuilder sb = new TextStringBuilder();
@@ -315,7 +313,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("foobarard");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_StringBuffer() {
         TextStringBuilder sb = new TextStringBuilder();
@@ -333,7 +330,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("foobar");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_StringBuffer_int_int() {
         TextStringBuilder sb = new TextStringBuilder();
@@ -393,7 +389,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("foobar");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_StringBuilder() {
         TextStringBuilder sb = new TextStringBuilder();
@@ -411,7 +406,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("foobar");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_StringBuilder_int_int() {
         TextStringBuilder sb = new TextStringBuilder();
@@ -474,7 +468,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("foobarard");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_TextStringBuilder() {
         TextStringBuilder sb = new TextStringBuilder();
@@ -492,7 +485,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("foobar");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppend_TextStringBuilder_int_int() {
         TextStringBuilder sb = new TextStringBuilder();
@@ -552,7 +544,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("foobar");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendAll_Array() {
         final TextStringBuilder sb = new TextStringBuilder();
@@ -572,7 +563,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("foobarbaz");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendAll_Collection() {
         final TextStringBuilder sb = new TextStringBuilder();
@@ -588,7 +578,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("foobarbaz");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendAll_Iterator() {
         final TextStringBuilder sb = new TextStringBuilder();
@@ -604,7 +593,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("foobarbaz");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendFixedWidthPadLeft() {
         final TextStringBuilder sb = new TextStringBuilder();
@@ -634,7 +622,7 @@ public class TextStringBuilderAppendInsertTest {
         sb.clear();
         sb.appendFixedWidthPadLeft("foo", 10, '-');
         assertThat(sb.length()).isEqualTo(10);
-        //            1234567890
+        // 1234567890
         assertThat(sb.toString()).isEqualTo("-------foo");
 
         sb.clear();
@@ -643,7 +631,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("-null");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendFixedWidthPadLeft_int() {
         final TextStringBuilder sb = new TextStringBuilder();
@@ -673,11 +660,10 @@ public class TextStringBuilderAppendInsertTest {
         sb.clear();
         sb.appendFixedWidthPadLeft(123, 10, '-');
         assertThat(sb.length()).isEqualTo(10);
-        //            1234567890
+        // 1234567890
         assertThat(sb.toString()).isEqualTo("-------123");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendFixedWidthPadRight() {
         final TextStringBuilder sb = new TextStringBuilder();
@@ -707,7 +693,7 @@ public class TextStringBuilderAppendInsertTest {
         sb.clear();
         sb.appendFixedWidthPadRight("foo", 10, '-');
         assertThat(sb.length()).isEqualTo(10);
-        //            1234567890
+        // 1234567890
         assertThat(sb.toString()).isEqualTo("foo-------");
 
         sb.clear();
@@ -716,7 +702,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("null-");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendFixedWidthPadRight_int() {
         final TextStringBuilder sb = new TextStringBuilder();
@@ -746,11 +731,10 @@ public class TextStringBuilderAppendInsertTest {
         sb.clear();
         sb.appendFixedWidthPadRight(123, 10, '-');
         assertThat(sb.length()).isEqualTo(10);
-        //            1234567890
+        // 1234567890
         assertThat(sb.toString()).isEqualTo("123-------");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_Boolean() {
         final TextStringBuilder sb = new TextStringBuilder();
@@ -762,82 +746,41 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("false" + SEP);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_CharArray() {
-        final int[] count = new int[2];
-        // TODO use mocking
-        final TextStringBuilder sb = new TextStringBuilder() {
-            private static final long serialVersionUID = 1L;
-
-            @Override
-            public TextStringBuilder append(final char[] str) {
-                count[0]++;
-                return super.append(str);
-            }
-            @Override
-            public TextStringBuilder appendNewLine() {
-                count[1]++;
-                return super.appendNewLine();
-            }
-        };
-        sb.appendln("foo".toCharArray());
+        final TextStringBuilder sb = spy(new TextStringBuilder());
+        final char[] input = "foo".toCharArray();
+        sb.appendln(input);
+
         assertThat(sb.toString()).isEqualTo("foo" + SEP);
-        assertThat(count[0]).isEqualTo(1);
-        assertThat(count[1]).isEqualTo(1);
+
+        verify(sb, times(1)).append(input);
+        verify(sb, times(1)).appendNewLine();
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_CharArray_int_int() {
-        final int[] count = new int[2];
-        // TODO use mocking
-        final TextStringBuilder sb = new TextStringBuilder() {
-            private static final long serialVersionUID = 1L;
-
-            @Override
-            public TextStringBuilder append(final char[] str, final int startIndex, final int length) {
-                count[0]++;
-                return super.append(str, startIndex, length);
-            }
-            @Override
-            public TextStringBuilder appendNewLine() {
-                count[1]++;
-                return super.appendNewLine();
-            }
-        };
-        sb.appendln("foo".toCharArray(), 0, 3);
+        final TextStringBuilder sb = spy(new TextStringBuilder());
+        final char[] input = "foo".toCharArray();
+        sb.appendln(input, 0, 3);
+
         assertThat(sb.toString()).isEqualTo("foo" + SEP);
-        assertThat(count[0]).isEqualTo(1);
-        assertThat(count[1]).isEqualTo(1);
+
+        verify(sb, times(1)).append(input, 0, 3);
+        verify(sb, times(1)).appendNewLine();
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_FormattedString() {
-        final int[] count = new int[2];
-        // TODO use mocking
-        final TextStringBuilder sb = new TextStringBuilder() {
-            private static final long serialVersionUID = 1L;
-
-            @Override
-            public TextStringBuilder append(final String str) {
-                count[0]++;
-                return super.append(str);
-            }
-            @Override
-            public TextStringBuilder appendNewLine() {
-                count[1]++;
-                return super.appendNewLine();
-            }
-        };
+        final TextStringBuilder sb = spy(new TextStringBuilder());
         sb.appendln("Hello %s", "Alice");
+
         assertThat(sb.toString()).isEqualTo("Hello Alice" + SEP);
-        assertThat(count[0]).isEqualTo(2); // appendNewLine() calls append(String)
-        assertThat(count[1]).isEqualTo(1);
+
+        verify(sb, times(2)).append(anyString()); // appendNewLine() calls append(String)
+        verify(sb, times(1)).appendNewLine();
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_Object() {
         final TextStringBuilder sb = new TextStringBuilder();
@@ -851,7 +794,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo(SEP + "foo" + SEP + "6" + SEP);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_PrimitiveNumber() {
         final TextStringBuilder sb = new TextStringBuilder();
@@ -871,207 +813,94 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("4.5" + SEP);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_String() {
-        final int[] count = new int[2];
-        // TODO use mocking
-        final TextStringBuilder sb = new TextStringBuilder() {
-            private static final long serialVersionUID = 1L;
-
-            @Override
-            public TextStringBuilder append(final String str) {
-                count[0]++;
-                return super.append(str);
-            }
-            @Override
-            public TextStringBuilder appendNewLine() {
-                count[1]++;
-                return super.appendNewLine();
-            }
-        };
+        final TextStringBuilder sb = spy(new TextStringBuilder());
         sb.appendln("foo");
+
         assertThat(sb.toString()).isEqualTo("foo" + SEP);
-        assertThat(count[0]).isEqualTo(2); // appendNewLine() calls append(String)
-        assertThat(count[1]).isEqualTo(1);
+
+        verify(sb, times(2)).append(anyString()); // appendNewLine() calls append(String)
+        verify(sb, times(1)).appendNewLine();
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_String_int_int() {
-        final int[] count = new int[2];
-        // TODO use mocking
-        final TextStringBuilder sb = new TextStringBuilder() {
-            private static final long serialVersionUID = 1L;
-
-            @Override
-            public TextStringBuilder append(final String str, final int startIndex, final int length) {
-                count[0]++;
-                return super.append(str, startIndex, length);
-            }
-            @Override
-            public TextStringBuilder appendNewLine() {
-                count[1]++;
-                return super.appendNewLine();
-            }
-        };
+        final TextStringBuilder sb = spy(new TextStringBuilder());
         sb.appendln("foo", 0, 3);
+
         assertThat(sb.toString()).isEqualTo("foo" + SEP);
-        assertThat(count[0]).isEqualTo(2); // appendNewLine() calls append(String)
-        assertThat(count[1]).isEqualTo(1);
+
+        verify(sb, times(2)).append(anyString(), anyInt(), anyInt()); // appendNewLine() calls append(String)
+        verify(sb, times(1)).appendNewLine();
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_StringBuffer() {
-        final int[] count = new int[2];
-        // TODO use mocking
-        final TextStringBuilder sb = new TextStringBuilder() {
-            private static final long serialVersionUID = 1L;
-
-            @Override
-            public TextStringBuilder append(final StringBuffer str) {
-                count[0]++;
-                return super.append(str);
-            }
-            @Override
-            public TextStringBuilder appendNewLine() {
-                count[1]++;
-                return super.appendNewLine();
-            }
-        };
+        final TextStringBuilder sb = spy(new TextStringBuilder());
         sb.appendln(new StringBuffer("foo"));
+
         assertThat(sb.toString()).isEqualTo("foo" + SEP);
-        assertThat(count[0]).isEqualTo(1);
-        assertThat(count[1]).isEqualTo(1);
+
+        verify(sb, times(1)).append(any(StringBuffer.class));
+        verify(sb, times(1)).appendNewLine();
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_StringBuffer_int_int() {
-        final int[] count = new int[2];
-        // TODO use mocking
-        final TextStringBuilder sb = new TextStringBuilder() {
-            private static final long serialVersionUID = 1L;
-
-            @Override
-            public TextStringBuilder append(final StringBuffer str, final int startIndex, final int length) {
-                count[0]++;
-                return super.append(str, startIndex, length);
-            }
-            @Override
-            public TextStringBuilder appendNewLine() {
-                count[1]++;
-                return super.appendNewLine();
-            }
-        };
+        final TextStringBuilder sb = spy(new TextStringBuilder());
         sb.appendln(new StringBuffer("foo"), 0, 3);
+
         assertThat(sb.toString()).isEqualTo("foo" + SEP);
-        assertThat(count[0]).isEqualTo(1);
-        assertThat(count[1]).isEqualTo(1);
+
+        verify(sb, times(1)).append(any(StringBuffer.class), anyInt(), anyInt());
+        verify(sb, times(1)).appendNewLine();
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_StringBuilder() {
-        final int[] count = new int[2];
-        // TODO use mocking
-        final TextStringBuilder sb = new TextStringBuilder() {
-            private static final long serialVersionUID = 1L;
-
-            @Override
-            public TextStringBuilder append(final StringBuilder str) {
-                count[0]++;
-                return super.append(str);
-            }
-            @Override
-            public TextStringBuilder appendNewLine() {
-                count[1]++;
-                return super.appendNewLine();
-            }
-        };
+        final TextStringBuilder sb = spy(new TextStringBuilder());
         sb.appendln(new StringBuilder("foo"));
+
         assertThat(sb.toString()).isEqualTo("foo" + SEP);
-        assertThat(count[0]).isEqualTo(1);
-        assertThat(count[1]).isEqualTo(1);
+
+        verify(sb, times(1)).append(any(StringBuilder.class));
+        verify(sb, times(1)).appendNewLine();
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_StringBuilder_int_int() {
-        final int[] count = new int[2];
-        // TODO use mocking
-        final TextStringBuilder sb = new TextStringBuilder() {
-            private static final long serialVersionUID = 1L;
-
-            @Override
-            public TextStringBuilder append(final StringBuilder str, final int startIndex, final int length) {
-                count[0]++;
-                return super.append(str, startIndex, length);
-            }
-            @Override
-            public TextStringBuilder appendNewLine() {
-                count[1]++;
-                return super.appendNewLine();
-            }
-        };
+        final TextStringBuilder sb = spy(new TextStringBuilder());
         sb.appendln(new StringBuilder("foo"), 0, 3);
+
         assertThat(sb.toString()).isEqualTo("foo" + SEP);
-        assertThat(count[0]).isEqualTo(1);
-        assertThat(count[1]).isEqualTo(1);
+
+        verify(sb, times(1)).append(any(StringBuilder.class), anyInt(), anyInt());
+        verify(sb, times(1)).appendNewLine();
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_TextStringBuilder() {
-        final int[] count = new int[2];
-        // TODO use mocking
-        final TextStringBuilder sb = new TextStringBuilder() {
-            private static final long serialVersionUID = 1L;
-
-            @Override
-            public TextStringBuilder append(final TextStringBuilder str) {
-                count[0]++;
-                return super.append(str);
-            }
-            @Override
-            public TextStringBuilder appendNewLine() {
-                count[1]++;
-                return super.appendNewLine();
-            }
-        };
+        final TextStringBuilder sb = spy(new TextStringBuilder());
         sb.appendln(new TextStringBuilder("foo"));
+
         assertThat(sb.toString()).isEqualTo("foo" + SEP);
-        assertThat(count[0]).isEqualTo(1);
-        assertThat(count[1]).isEqualTo(1);
+
+        verify(sb, times(1)).append(any(TextStringBuilder.class));
+        verify(sb, times(1)).appendNewLine();
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendln_TextStringBuilder_int_int() {
-        final int[] count = new int[2];
-        // TODO use mocking
-        final TextStringBuilder sb = new TextStringBuilder() {
-            private static final long serialVersionUID = 1L;
-
-            @Override
-            public TextStringBuilder append(final TextStringBuilder str, final int startIndex, final int length) {
-                count[0]++;
-                return super.append(str, startIndex, length);
-            }
-            @Override
-            public TextStringBuilder appendNewLine() {
-                count[1]++;
-                return super.appendNewLine();
-            }
-        };
+        final TextStringBuilder sb = spy(new TextStringBuilder());
         sb.appendln(new TextStringBuilder("foo"), 0, 3);
+
         assertThat(sb.toString()).isEqualTo("foo" + SEP);
-        assertThat(count[0]).isEqualTo(1);
-        assertThat(count[1]).isEqualTo(1);
+
+        verify(sb, times(1)).append(any(TextStringBuilder.class), anyInt(), anyInt());
+        verify(sb, times(1)).appendNewLine();
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendNewLine() {
         TextStringBuilder sb = new TextStringBuilder("---");
@@ -1083,7 +912,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("---#" + SEP);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendPadding() {
         final TextStringBuilder sb = new TextStringBuilder();
@@ -1101,15 +929,14 @@ public class TextStringBuilderAppendInsertTest {
 
         sb.appendPadding(16, '-');
         assertThat(sb.length()).isEqualTo(20);
-        //            12345678901234567890
+        // 12345678901234567890
         assertThat(sb.toString()).isEqualTo("foo-----------------");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendSeparator_char() {
         final TextStringBuilder sb = new TextStringBuilder();
-        sb.appendSeparator(',');  // no effect
+        sb.appendSeparator(','); // no effect
         assertThat(sb.toString()).isEqualTo("");
         sb.append("foo");
         assertThat(sb.toString()).isEqualTo("foo");
@@ -1123,7 +950,7 @@ public class TextStringBuilderAppendInsertTest {
         final char startSeparator = ':';
         final char standardSeparator = ',';
         final String foo = "foo";
-        sb.appendSeparator(standardSeparator, startSeparator);  // no effect
+        sb.appendSeparator(standardSeparator, startSeparator); // no effect
         assertThat(sb.toString()).isEqualTo(String.valueOf(startSeparator));
         sb.append(foo);
         assertThat(sb.toString()).isEqualTo(String.valueOf(startSeparator) + foo);
@@ -1131,26 +958,24 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo(String.valueOf(startSeparator) + foo + standardSeparator);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendSeparator_char_int() {
         final TextStringBuilder sb = new TextStringBuilder();
-        sb.appendSeparator(',', 0);  // no effect
+        sb.appendSeparator(',', 0); // no effect
         assertThat(sb.toString()).isEqualTo("");
         sb.append("foo");
         assertThat(sb.toString()).isEqualTo("foo");
         sb.appendSeparator(',', 1);
         assertThat(sb.toString()).isEqualTo("foo,");
 
-        sb.appendSeparator(',', -1);  // no effect
+        sb.appendSeparator(',', -1); // no effect
         assertThat(sb.toString()).isEqualTo("foo,");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendSeparator_String() {
         final TextStringBuilder sb = new TextStringBuilder();
-        sb.appendSeparator(",");  // no effect
+        sb.appendSeparator(","); // no effect
         assertThat(sb.toString()).isEqualTo("");
         sb.append("foo");
         assertThat(sb.toString()).isEqualTo("foo");
@@ -1158,22 +983,20 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("foo,");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendSeparator_String_int() {
         final TextStringBuilder sb = new TextStringBuilder();
-        sb.appendSeparator(",", 0);  // no effect
+        sb.appendSeparator(",", 0); // no effect
         assertThat(sb.toString()).isEqualTo("");
         sb.append("foo");
         assertThat(sb.toString()).isEqualTo("foo");
         sb.appendSeparator(",", 1);
         assertThat(sb.toString()).isEqualTo("foo,");
 
-        sb.appendSeparator(",", -1);  // no effect
+        sb.appendSeparator(",", -1); // no effect
         assertThat(sb.toString()).isEqualTo("foo,");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendSeparator_String_String() {
         final TextStringBuilder sb = new TextStringBuilder();
@@ -1196,7 +1019,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo(startSeparator + foo + standardSeparator);
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendWithNullText() {
         final TextStringBuilder sb = new TextStringBuilder();
@@ -1228,7 +1050,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("NULLNULLfooNULLbarNULLbaz");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendWithSeparators_Array() {
         final TextStringBuilder sb = new TextStringBuilder();
@@ -1240,19 +1061,18 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("");
 
         sb.clear();
-        sb.appendWithSeparators(new Object[]{"foo", "bar", "baz"}, ",");
+        sb.appendWithSeparators(new Object[] {"foo", "bar", "baz"}, ",");
         assertThat(sb.toString()).isEqualTo("foo,bar,baz");
 
         sb.clear();
-        sb.appendWithSeparators(new Object[]{"foo", "bar", "baz"}, null);
+        sb.appendWithSeparators(new Object[] {"foo", "bar", "baz"}, null);
         assertThat(sb.toString()).isEqualTo("foobarbaz");
 
         sb.clear();
-        sb.appendWithSeparators(new Object[]{"foo", null, "baz"}, ",");
+        sb.appendWithSeparators(new Object[] {"foo", null, "baz"}, ",");
         assertThat(sb.toString()).isEqualTo("foo,,baz");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendWithSeparators_Collection() {
         final TextStringBuilder sb = new TextStringBuilder();
@@ -1275,7 +1095,7 @@ public class TextStringBuilderAppendInsertTest {
         sb.appendWithSeparators(Arrays.asList("foo", null, "baz"), ",");
         assertThat(sb.toString()).isEqualTo("foo,,baz");
     }
-    //-----------------------------------------------------------------------
+
     @Test
     public void testAppendWithSeparators_Iterator() {
         final TextStringBuilder sb = new TextStringBuilder();
@@ -1299,12 +1119,11 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("foo,,baz");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testAppendWithSeparatorsWithNullText() {
         final TextStringBuilder sb = new TextStringBuilder();
         sb.setNullText("null");
-        sb.appendWithSeparators(new Object[]{"foo", null, "baz"}, ",");
+        sb.appendWithSeparators(new Object[] {"foo", null, "baz"}, ",");
         assertThat(sb.toString()).isEqualTo("foo,null,baz");
 
         sb.clear();
@@ -1312,7 +1131,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("foo,null,baz");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testInsert() {
 
@@ -1348,9 +1166,9 @@ public class TextStringBuilderAppendInsertTest {
         sb.append("barbaz");
         assertThat(sb.toString()).isEqualTo("barbaz");
 
-        assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, new char[]{'f', 'o', 'o'}));
+        assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, new char[] {'f', 'o', 'o'}));
 
-        assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, new char[]{'f', 'o', 'o'}));
+        assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, new char[] {'f', 'o', 'o'}));
 
         sb.insert(0, (char[]) null);
         assertThat(sb.toString()).isEqualTo("barbaz");
@@ -1358,7 +1176,7 @@ public class TextStringBuilderAppendInsertTest {
         sb.insert(0, ArrayUtils.EMPTY_CHAR_ARRAY);
         assertThat(sb.toString()).isEqualTo("barbaz");
 
-        sb.insert(0, new char[]{'f', 'o', 'o'});
+        sb.insert(0, new char[] {'f', 'o', 'o'});
         assertThat(sb.toString()).isEqualTo("foobarbaz");
 
         sb.clear();
@@ -1366,10 +1184,10 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("barbaz");
 
         assertThrows(IndexOutOfBoundsException.class,
-                () -> sb.insert(-1, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 3, 3));
+            () -> sb.insert(-1, new char[] {'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 3, 3));
 
         assertThrows(IndexOutOfBoundsException.class,
-                () -> sb.insert(7, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 3, 3));
+            () -> sb.insert(7, new char[] {'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 3, 3));
 
         sb.insert(0, (char[]) null, 0, 0);
         assertThat(sb.toString()).isEqualTo("barbaz");
@@ -1378,21 +1196,21 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("barbaz");
 
         assertThrows(IndexOutOfBoundsException.class,
-                () -> sb.insert(0, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, -1, 3));
+            () -> sb.insert(0, new char[] {'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, -1, 3));
 
         assertThrows(IndexOutOfBoundsException.class,
-                () -> sb.insert(0, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 10, 3));
+            () -> sb.insert(0, new char[] {'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 10, 3));
 
         assertThrows(IndexOutOfBoundsException.class,
-                () -> sb.insert(0, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 0, -1));
+            () -> sb.insert(0, new char[] {'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 0, -1));
 
         assertThrows(IndexOutOfBoundsException.class,
-                () -> sb.insert(0, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 0, 10));
+            () -> sb.insert(0, new char[] {'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 0, 10));
 
-        sb.insert(0, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 0, 0);
+        sb.insert(0, new char[] {'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 0, 0);
         assertThat(sb.toString()).isEqualTo("barbaz");
 
-        sb.insert(0, new char[]{'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 3, 3);
+        sb.insert(0, new char[] {'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f'}, 3, 3);
         assertThat(sb.toString()).isEqualTo("foobarbaz");
 
         sb.clear();
@@ -1465,7 +1283,6 @@ public class TextStringBuilderAppendInsertTest {
         assertThat(sb.toString()).isEqualTo("4.5barbaz");
     }
 
-    //-----------------------------------------------------------------------
     @Test
     public void testInsertWithNullText() {
         final TextStringBuilder sb = new TextStringBuilder();