content: /*
   * This file was automatically generated by UTestGen and EvoSuite
   * Mon Mar 18 16:00:05 GMT 2024
   */
  
  package org.apache.commons.lang3.text;
  
  import org.junit.jupiter.api.Test;
  import static org.junit.jupiter.api.Assertions.*;
  import org.junit.jupiter.api.Timeout;
  import java.util.concurrent.TimeUnit;
  import static org.evosuite.runtime.EvoAssertions.*;
  import java.util.ArrayDeque;
  import java.util.EnumSet;
  import java.util.Iterator;
  import java.util.Locale;
  import java.util.NoSuchElementException;
  import java.util.Stack;
  import org.apache.commons.lang3.text.StrBuilder;
  import org.apache.commons.lang3.text.StrMatcher;
  import org.evosuite.runtime.EvoRunner;
  import org.evosuite.runtime.EvoRunnerParameters;
  import org.junit.runner.RunWith;
  
  @RunWith(EvoRunner.class) @EvoRunnerParameters(mockJVMNonDeterminism = true, useVFS = true, useVNET = true, resetStaticState = true, separateClassLoader = true) 
  public class StrBuilder_Original_ESTest extends StrBuilder_Original_ESTest_scaffolding {
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReady() throws Throwable  {
        StrBuilder arg0 = new StrBuilder("wJW,nQ");
        StrBuilder.StrBuilderReader strBuilder_StrBuilderReader = arg0.new StrBuilderReader();
        boolean ready = strBuilder_StrBuilderReader.ready();
        assertEquals(7, arg0.size());
        assertEquals(7, arg0.length());
        assertTrue(ready);
        assertEquals(39, arg0.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testValidateIndex() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("java.vendor.url");
        strBuilder.validateIndex(2);
        assertEquals(15, strBuilder.length());
        assertEquals(47, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHashCode() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.hashCode();
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testValidateRangeReturningZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.validateRange(0, 753);
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testValidateRangeReturningPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("M");
        strBuilder.validateRange(1, 93);
        assertEquals(33, strBuilder.capacity());
        assertEquals(1, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testTrimReturningStrBuilderWhereCapacityIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(44);
        assertEquals(44, strBuilder.capacity());
        
        strBuilder.minimizeCapacity();
        strBuilder.trim();
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToStringBufferReturningStringBufferWhereLengthIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StringBuilder arg0 = new StringBuilder("org.apache.commons.lang3.ArrayUtils");
        strBuilder.append(arg0);
        strBuilder.toStringBuffer();
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToStringReturningEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(0);
        String string = strBuilder.toString();
        assertEquals(32, strBuilder.capacity());
        assertEquals("", string);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubstringTaking2ArgumentsReturningEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.append((Object) "w4`&?*jk^v>fy2xsO+l");
        strBuilder.substring(2, 2);
        assertEquals(27, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubSequenceReturningCharSequenceWhereLengthIsPositive() throws Throwable  {
        StrBuilder arg0 = new StrBuilder("'Rd~CHa$");
        StrBuilder append = arg0.append((Object) arg0);
        CharSequence subSequence = append.subSequence(0, 46);
        assertEquals(59, arg0.length());
        assertEquals("'Rd~CHa$org.apache.commons.lang3.text.StrBuild", subSequence);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSizeReturningPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.appendln(46);
        int size = strBuilder.size();
        assertEquals(3, strBuilder.length());
        assertEquals(3, size);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetNullTextReturningStrBuilderWhereCapacityIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        assertEquals(32, strBuilder.capacity());
        
        strBuilder.minimizeCapacity();
        strBuilder.setNullText("");
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetNewLineTextReturningStrBuilderWhereCapacityIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        assertEquals(32, strBuilder.capacity());
        
        strBuilder.minimizeCapacity();
        strBuilder.setNewLineText("null comparator");
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReplaceFirstTaking2StringsReturningStrBuilderWhereCapacityIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        assertEquals(32, strBuilder.capacity());
        
        strBuilder.minimizeCapacity();
        strBuilder.replaceFirst((String) null, "");
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReplaceFirstTaking2CharsReturningStrBuilderWhereCapacityIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        assertEquals(32, strBuilder.capacity());
        
        StrBuilder minimizeCapacity = strBuilder.minimizeCapacity();
        minimizeCapacity.replaceFirst('K', 'n');
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReplaceAllTaking1And1ReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.minimizeCapacity();
        StrMatcher arg0 = StrMatcher.splitMatcher();
        strBuilder.replaceAll(arg0, (String) null);
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLengthReturningZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        int length = strBuilder.length();
        assertEquals(32, strBuilder.capacity());
        assertEquals(0, length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLengthReturningPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.append("length must be valid");
        int length = strBuilder.length();
        assertEquals(20, length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTakingStrMatcherReturningZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(1);
        strBuilder.appendNewLine();
        StrMatcher arg0 = StrMatcher.trimMatcher();
        int lastIndexOf = strBuilder.lastIndexOf(arg0);
        assertFalse(strBuilder.isEmpty());
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendlnTakingCharArray() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] arg0 = new char[7];
        arg0[0] = 'R';
        strBuilder.appendln(arg0);
        int lastIndexOf = strBuilder.lastIndexOf('R');
        assertEquals(8, strBuilder.size());
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTakingCharReturningPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(97);
        StrBuilder appendFixedWidthPadLeft = strBuilder.appendFixedWidthPadLeft(97, 97, '(');
        int lastIndexOf = appendFixedWidthPadLeft.lastIndexOf('0');
        assertEquals(97, strBuilder.size());
        assertEquals(95, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking4ArgumentsReturningStrBuilderWhereCapacityIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] arg1 = new char[0];
        strBuilder.buffer = arg1;
        StrBuilder insert = strBuilder.insert(0, arg1, 0, 0);
        assertEquals(0, insert.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking1And1ReturningStrBuilderWhereCapacityIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(44);
        assertEquals(44, strBuilder.capacity());
        
        StrBuilder minimizeCapacity = strBuilder.minimizeCapacity();
        minimizeCapacity.insert(0, (char[]) null);
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking1And1ReturningStrBuilderWhereSizeIsPositiveAndAppendTakingCharArray() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] arg0 = new char[1];
        StrBuilder append = strBuilder.append(arg0);
        append.insert(0, (Object) null);
        assertFalse(strBuilder.isEmpty());
        assertEquals(1, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking1And1AndAppendFixedWidthPadRightTaking11And1AndInsertTaking1And1() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        arg0.appendFixedWidthPadRight((Object) arg0, 97, 'J');
        arg0.insert(5, 710L);
        assertEquals(194, arg0.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking2Ints() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        StrBuilder appendFixedWidthPadRight = arg0.appendFixedWidthPadRight((Object) arg0, 97, 'J');
        appendFixedWidthPadRight.insert(5, 5);
        assertEquals(98, appendFixedWidthPadRight.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking1And1AndAppendFixedWidthPadLeftTaking2IntsAnd1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(97);
        strBuilder.appendFixedWidthPadLeft(97, 97, '(');
        strBuilder.insert(97, 423.7924909687189);
        assertEquals(114, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndIndexOfTaking1And1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder appendNewLine = strBuilder.appendNewLine();
        StrMatcher.TrimMatcher arg0 = new StrMatcher.TrimMatcher();
        int indexOf = appendNewLine.indexOf((StrMatcher) arg0, (-179));
        assertFalse(strBuilder.isEmpty());
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTakingStrMatcherReturningNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("java.vm.name");
        StrMatcher arg0 = StrMatcher.tabMatcher();
        int indexOf = strBuilder.indexOf(arg0);
        assertEquals(44, strBuilder.capacity());
        assertEquals((-1), indexOf);
        assertEquals(12, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTakingCharReturningZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(97);
        StrBuilder appendFixedWidthPadLeft = strBuilder.appendFixedWidthPadLeft(97, 97, '5');
        int indexOf = appendFixedWidthPadLeft.indexOf('5');
        assertFalse(strBuilder.isEmpty());
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTakingCharReturningNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("V|");
        int indexOf = strBuilder.indexOf('\'');
        assertEquals((-1), indexOf);
        assertEquals(34, strBuilder.capacity());
        assertEquals(2, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetNullTextReturningNonEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("|p);B?vWxH|;Bcm");
        strBuilder.setNullText("|p);B?vWxH|;Bcm");
        String nullText = strBuilder.getNullText();
        assertNotNull(nullText);
        assertEquals(15, strBuilder.length());
        assertEquals(47, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEnsureCapacityReturningStrBuilderWhereCapacityIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(44);
        assertEquals(44, strBuilder.capacity());
        
        StrBuilder minimizeCapacity = strBuilder.minimizeCapacity();
        minimizeCapacity.ensureCapacity(0);
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteFirstTakingStrMatcherReturningStrBuilderWhereCapacityIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        assertEquals(32, strBuilder.capacity());
        
        StrBuilder minimizeCapacity = strBuilder.minimizeCapacity();
        StrMatcher.TrimMatcher arg0 = new StrMatcher.TrimMatcher();
        minimizeCapacity.deleteFirst((StrMatcher) arg0);
        assertEquals(0, strBuilder.capacity());
        assertEquals(0, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteFirstTakingStringReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder arg0 = new StrBuilder(97);
        arg0.appendFixedWidthPadRight((Object) arg0, 97, 'X');
        arg0.deleteFirst("^]B|(p{");
        assertFalse(arg0.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteFirstTakingStringReturningStrBuilderWhereCapacityIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        assertEquals(32, strBuilder.capacity());
        
        strBuilder.minimizeCapacity();
        strBuilder.deleteFirst("iS\fm#Q\"*`a=&f%n '");
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteFirstTakingCharReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder deleteFirst = strBuilder.deleteFirst('j');
        assertEquals(32, deleteFirst.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteCharAtReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.appendSeparator('M', 'M');
        assertFalse(strBuilder.isEmpty());
        
        strBuilder.deleteCharAt(0);
        assertEquals(0, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteAllTakingStrMatcherReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        assertEquals(32, strBuilder.capacity());
        
        StrBuilder minimizeCapacity = strBuilder.minimizeCapacity();
        StrMatcher arg0 = StrMatcher.stringMatcher("Z!`)?]7i");
        minimizeCapacity.deleteAll(arg0);
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteAllTakingStringReturningStrBuilderWhereCapacityIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        assertEquals(32, strBuilder.capacity());
        
        strBuilder.minimizeCapacity();
        strBuilder.deleteAll("H3qX8Z7^_t");
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteAllTakingCharReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(44);
        assertEquals(44, strBuilder.capacity());
        
        strBuilder.minimizeCapacity();
        strBuilder.deleteAll('h');
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCharAtReturningOtherChar() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("java.vendor.url");
        strBuilder.size = 5;
        strBuilder.appendln((-169.0));
        char charAt = strBuilder.charAt(5);
        assertEquals(12, strBuilder.size());
        assertEquals('-', charAt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCharAtReturningDigit() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("java.vendor.url");
        StrBuilder clear = strBuilder.clear();
        clear.appendln((-169.0));
        char charAt = strBuilder.charAt(2);
        assertEquals(7, strBuilder.size());
        assertEquals('6', charAt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCharAtReturningAlphabeticChar() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("org.apache.commons.lang3.JavaVersion");
        char charAt = strBuilder.charAt(2);
        assertEquals('g', charAt);
        assertEquals(36, strBuilder.size());
        assertEquals(68, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBuildReturningEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        String build = strBuilder.build();
        assertEquals("", build);
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendlnTakingStrBuilderReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder arg0 = strBuilder.setNewLineText("");
        StrBuilder appendln = strBuilder.appendln(arg0);
        assertTrue(appendln.isEmpty());
        assertEquals(32, appendln.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendWithSeparatorsTaking1And1() throws Throwable  {
        Stack<Locale.FilteringMode> stack = new Stack<Locale.FilteringMode>();
        StrBuilder strBuilder = new StrBuilder(44);
        assertEquals(44, strBuilder.capacity());
        
        StrBuilder minimizeCapacity = strBuilder.minimizeCapacity();
        Iterator<Locale.FilteringMode> arg0 = stack.iterator();
        minimizeCapacity.appendWithSeparators(arg0, "s");
        assertEquals(0, strBuilder.capacity());
        assertEquals(0, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendSeparatorTaking2StringsReturningStrBuilderWhereCapacityIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("java.vendor.url");
        StrBuilder deleteAll = strBuilder.deleteAll("java.vendor.url");
        strBuilder.minimizeCapacity();
        deleteAll.appendSeparator("os.arch", "");
        assertEquals(0, strBuilder.length());
        assertTrue(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendSeparatorTaking1And1ReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.appendSeparator("Invalid startIndex: ", 7);
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendSeparatorTakingStringReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        assertEquals(32, strBuilder.capacity());
        
        strBuilder.minimizeCapacity();
        strBuilder.appendSeparator("org.apache.commons.lang3.text.StrBuilder$StrBuilderReader");
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendSeparatorTakingCharReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        assertEquals(32, strBuilder.capacity());
        
        strBuilder.minimizeCapacity();
        strBuilder.appendSeparator('X');
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendNullReturningStrBuilderWhereCapacityIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        assertEquals(32, strBuilder.capacity());
        
        strBuilder.minimizeCapacity();
        strBuilder.appendNull();
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendFixedWidthPadRightTaking2IntsAnd1ReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        assertEquals(32, strBuilder.capacity());
        
        StrBuilder minimizeCapacity = strBuilder.minimizeCapacity();
        minimizeCapacity.appendFixedWidthPadRight(739, (-2965), '8');
        assertEquals(0, strBuilder.capacity());
        assertTrue(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendAllTakingObjectArrayReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder[] arg0 = new StrBuilder[2];
        arg0[0] = strBuilder;
        strBuilder.appendAll(arg0);
        assertEquals(51, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendAllTakingIteratorReturningStrBuilderWhereCapacityIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        assertEquals(32, strBuilder.capacity());
        
        strBuilder.minimizeCapacity();
        ArrayDeque<Object> arrayDeque = new ArrayDeque<Object>();
        Iterator<Object> arg0 = arrayDeque.iterator();
        strBuilder.appendAll(arg0);
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsReturningStrBuilderWhereCapacityIsZeroAndCreatesStrBuilderTakingNoArguments() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        assertEquals(32, strBuilder.capacity());
        
        StrBuilder minimizeCapacity = strBuilder.minimizeCapacity();
        minimizeCapacity.append((char[]) null, (-204), 102);
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingCharArrayReturningStrBuilderWhereLengthIsNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder appendln = strBuilder.appendln(2);
        appendln.size = (-3320);
        char[] arg0 = new char[0];
        appendln.append(arg0);
        assertEquals((-3320), appendln.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingStrBuilderReturningStrBuilderWhereCapacityIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        assertEquals(32, strBuilder.capacity());
        
        StrBuilder arg0 = strBuilder.minimizeCapacity();
        arg0.append(arg0);
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingStringBufferReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        assertEquals(32, strBuilder.capacity());
        
        strBuilder.minimizeCapacity();
        strBuilder.append((StringBuffer) null);
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndCreatesStrBuilderTakingNoArguments() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.append("\n", (Object[]) null);
        StrMatcher arg0 = StrMatcher.splitMatcher();
        int lastIndexOf = strBuilder.lastIndexOf(arg0, 11);
        assertFalse(strBuilder.isEmpty());
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsReturningStrBuilderWhereCapacityIsZeroAndCreatesStrBuilderTakingInt() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(3574);
        assertEquals(3574, strBuilder.capacity());
        
        StrBuilder minimizeCapacity = strBuilder.minimizeCapacity();
        minimizeCapacity.append((CharSequence) null, 3574, 3574);
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsTakingStrBuilderWithStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        boolean equals = arg0.equals(arg0);
        assertEquals(32, arg0.capacity());
        assertTrue(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndLastIndexOfTaking1And10() throws Throwable  {
        StrMatcher arg0 = StrMatcher.charSetMatcher("ZMlR-{eLr)JnK");
        StrBuilder strBuilder = new StrBuilder("ZMlR-{eLr)JnK");
        int lastIndexOf = strBuilder.lastIndexOf(arg0, 3445);
        assertEquals(13, strBuilder.length());
        assertEquals(45, strBuilder.capacity());
        assertEquals(12, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesStrBuilderTakingStringAndLastIndexOfTaking1And1AndLastIndexOfTaking1And1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("java.vm.name");
        StrMatcher arg0 = StrMatcher.splitMatcher();
        int lastIndexOf = strBuilder.lastIndexOf(arg0, 537);
        assertEquals(44, strBuilder.capacity());
        assertEquals((-1), lastIndexOf);
        assertEquals(12, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendFixedWidthPadRightTaking11And1() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        StrBuilder appendFixedWidthPadRight = arg0.appendFixedWidthPadRight((Object) arg0, 97, 'J');
        int lastIndexOf = appendFixedWidthPadRight.lastIndexOf("ZMlR-{eLr)JnK", 5);
        assertFalse(arg0.isEmpty());
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndLastIndexOfTaking1And10() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("ZMlR-{eLr)JnK");
        int lastIndexOf = strBuilder.lastIndexOf("ZMlR-{eLr)JnK", 3003);
        assertEquals(0, lastIndexOf);
        assertEquals(45, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndCreatesStrBuilderTakingNoArguments() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        StrBuilder appendFixedWidthPadRight = arg0.appendFixedWidthPadRight((Object) arg0, 97, 'J');
        int lastIndexOf = appendFixedWidthPadRight.lastIndexOf("", 97);
        assertFalse(arg0.isEmpty());
        assertEquals(96, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1AndCreatesStrBuilderTakingNoArgumentsAndAppendFixedWidthPadRightTaking11And1() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        arg0.appendFixedWidthPadRight((Object) arg0, 97, 'J');
        int lastIndexOf = arg0.lastIndexOf('%', 118);
        assertFalse(arg0.isEmpty());
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndLastIndexOfTaking1And11() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(" 6$BZ|+H^D(bV");
        int lastIndexOf = strBuilder.lastIndexOf(' ', 0);
        assertEquals(45, strBuilder.capacity());
        assertEquals(13, strBuilder.size());
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesStrBuilderTakingNoArgumentsAndCallsIndexOfTaking1And1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrMatcher.TrimMatcher arg0 = new StrMatcher.TrimMatcher();
        int indexOf = strBuilder.indexOf((StrMatcher) arg0, (-179));
        assertEquals(32, strBuilder.capacity());
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1WithEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        int indexOf = strBuilder.indexOf("", (-2202));
        assertEquals(32, strBuilder.capacity());
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1WithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        int indexOf = strBuilder.indexOf((String) null, 34);
        assertEquals(32, strBuilder.capacity());
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1WithNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(115);
        strBuilder.appendln((-1.0));
        int indexOf = strBuilder.indexOf('t', (-128));
        assertEquals(5, strBuilder.length());
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndCreatesStrBuilderTakingNoArguments() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        StrBuilder appendFixedWidthPadRight = arg0.appendFixedWidthPadRight((Object) arg0, 97, 'J');
        int indexOf = appendFixedWidthPadRight.indexOf('J', 31);
        assertFalse(arg0.isEmpty());
        assertEquals(51, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesStrBuilderTakingIntAndCallsIndexOfTaking1And1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(102);
        int indexOf = strBuilder.indexOf('r', 102);
        assertEquals((-1), indexOf);
        assertEquals(102, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteAllTakingStringReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("org.apache.commons.lang3.JavaVersion");
        strBuilder.delete(2, 105);
        strBuilder.deleteAll("org.apache.commons.lang3.JavaVersion");
        assertEquals(2, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking1And1WithPositiveAndNonEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("java.vendor.url");
        strBuilder.setNewLineText("org.apache.commons.lang3.JavaVersion");
        strBuilder.appendln((-169.0));
        strBuilder.insert(30, "Z/q]~8`b$");
        assertEquals(114, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking1And1WithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(" 6$BZ|+H^D(bV");
        StrBuilder insert = strBuilder.insert(0, (String) null);
        assertEquals(45, insert.capacity());
        assertEquals(13, insert.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendFixedWidthPadLeftTaking11And1ReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder arg0 = new StrBuilder(97);
        StrBuilder appendFixedWidthPadLeft = arg0.appendFixedWidthPadLeft((Object) arg0, (-1), 'u');
        assertEquals(97, appendFixedWidthPadLeft.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendSeparatorTaking2StringsReturningStrBuilderWhereCapacityIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("java.vendor.url");
        StrBuilder deleteAll = strBuilder.deleteAll("java.vendor.url");
        deleteAll.appendSeparator("os.arch", "");
        assertTrue(strBuilder.isEmpty());
        assertEquals(0, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingBooleanWithTrue() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.append(true);
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsWithZeroAndAppendTaking1And2IntsAndAppendTaking1And2Ints0() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] arg0 = new char[1];
        StrBuilder append = strBuilder.append(arg0, 0, 0);
        assertEquals(32, append.capacity());
        assertEquals(0, append.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingCharArrayReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] arg0 = new char[1];
        strBuilder.append(arg0);
        int indexOf = strBuilder.indexOf("Lq30LX-/P6:Y", (-2297));
        assertFalse(strBuilder.isEmpty());
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingCharArrayReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] arg0 = new char[0];
        StrBuilder append = strBuilder.append(arg0);
        assertEquals(32, append.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsReturningStrBuilderWhereSizeIsPositiveAndAppendTaking1And2Ints0() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder arg0 = new StrBuilder("end < start");
        strBuilder.append(arg0, 3, 3);
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsWithPositiveAndAppendTaking1And2IntsThrowsStringIndexOutOfBoundsException0() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        // Undeclared exception!
        try { 
          arg0.append(arg0, 3, 3);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // startIndex must be valid
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingStrBuilder() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        StrBuilder append = arg0.append(arg0);
        assertEquals(32, append.capacity());
        assertEquals(0, append.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsAndCreatesStrBuilderTakingStringAndAppendTaking1And2Ints() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("...");
        StrBuilder append = strBuilder.append((StringBuilder) null, 0, 2082);
        assertEquals(35, append.capacity());
        assertEquals(3, append.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingStringBuilderReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StringBuilder arg0 = new StringBuilder();
        StrBuilder append = strBuilder.append(arg0);
        assertEquals(32, append.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsReturningStrBuilderWhereSizeIsPositiveAndAppendTaking1And2Ints1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("-HAEsP):;AW\"2o");
        StringBuffer arg0 = new StringBuffer("");
        StrBuilder append = strBuilder.append(arg0, 0, 0);
        assertEquals(46, append.capacity());
        assertEquals(14, append.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingStringBufferReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(44);
        StringBuffer arg0 = new StringBuffer((CharSequence) "Index: ");
        strBuilder.append(arg0);
        assertEquals(7, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubstringTaking2ArgumentsReturningNonEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder append = strBuilder.append("org.apache.commons.lang3.ArrayUtils");
        String substring = append.substring(32, 3603);
        assertEquals(70, strBuilder.capacity());
        assertEquals("ils", substring);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingStringWithEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder append = strBuilder.append("");
        assertEquals(32, append.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingObjectReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder append = strBuilder.append((Object) null);
        assertEquals(32, append.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder appendNull = strBuilder.appendNull();
        assertEquals(32, appendNull.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetCharsTaking4ArgumentsThrowsArrayIndexOutOfBoundsException() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("java.vendor.url");
        StrBuilder setNewLineText = strBuilder.setNewLineText("org.apache.commons.lang3.JavaVersion");
        StrBuilder appendln = setNewLineText.appendln((-169.0));
        setNewLineText.append((-33.0707545866898));
        appendln.appendln((-514));
        char[] arg2 = new char[2];
        // Undeclared exception!
        try { 
          setNewLineText.getChars(2, 99, arg2, (-514));
          fail("Expecting exception: ArrayIndexOutOfBoundsException");
        
        } catch(ArrayIndexOutOfBoundsException e) {
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyReturningFalse() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(97);
        StrBuilder appendFixedWidthPadLeft = strBuilder.appendFixedWidthPadLeft(97, 97, '(');
        boolean empty = appendFixedWidthPadLeft.isEmpty();
        assertEquals(97, strBuilder.size());
        assertFalse(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyReturningTrue() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        boolean empty = strBuilder.isEmpty();
        assertTrue(empty);
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEnsureCapacityWithPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.ensureCapacity(127);
        assertEquals(254, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEnsureCapacityReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("y6$B0|+},D(bV");
        StrBuilder ensureCapacity = strBuilder.ensureCapacity((-1194));
        assertEquals(13, ensureCapacity.length());
        assertEquals(45, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToStringReturningNonEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(" 6$BZ|+H^D(bV");
        String string = strBuilder.toString();
        assertEquals(45, strBuilder.capacity());
        assertEquals(" 6$BZ|+H^D(bV", string);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetNullTextReturningNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.getNullText();
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingLong() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.append((-1L));
        assertEquals(2, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ArgumentsReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder append = strBuilder.append("", (Object[]) null);
        assertEquals(32, append.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingFloat() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("<#j[s7HF");
        strBuilder.append((float) 0);
        assertEquals(11, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingChar() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.append(' ');
        assertEquals(1, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReplaceTaking5Arguments() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrMatcher arg0 = StrMatcher.charMatcher('P');
        StrBuilder replace = strBuilder.replace(arg0, "s@", 0, 0, (-248));
        assertEquals(32, replace.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSizeReturningZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        int size = strBuilder.size();
        assertEquals(32, strBuilder.capacity());
        assertEquals(0, size);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesStrBuilderTakingStringAndCallsSkip() throws Throwable  {
        StrBuilder arg0 = new StrBuilder("'Rd~CHa$");
        StrBuilder.StrBuilderReader strBuilder_StrBuilderReader = arg0.new StrBuilderReader();
        long skip = strBuilder_StrBuilderReader.skip(63L);
        assertFalse(strBuilder_StrBuilderReader.ready());
        assertEquals(8L, skip);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesStrBuilderTakingNoArgumentsAndCallsSkip() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        StrBuilder.StrBuilderReader strBuilder_StrBuilderReader = arg0.new StrBuilderReader();
        long skip = strBuilder_StrBuilderReader.skip((-86L));
        assertEquals(0L, skip);
        assertEquals(32, arg0.capacity());
        assertEquals(0, arg0.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReadTaking3Arguments() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        StrBuilder.StrBuilderReader strBuilder_StrBuilderReader = arg0.new StrBuilderReader();
        // Undeclared exception!
        try { 
          strBuilder_StrBuilderReader.read((char[]) null, 116, (-583));
          fail("Expecting exception: IndexOutOfBoundsException");
        
        } catch(IndexOutOfBoundsException e) {
           //
           // no message in exception (getMessage() returned null)
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder$StrBuilderReader", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReadTakingNoArguments() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        StrBuilder.StrBuilderReader strBuilder_StrBuilderReader = arg0.new StrBuilderReader();
        assertFalse(strBuilder_StrBuilderReader.ready());
        
        int read = strBuilder_StrBuilderReader.read();
        assertEquals(0, arg0.size());
        assertEquals(32, arg0.capacity());
        assertEquals((-1), read);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetContent() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        StrBuilder.StrBuilderTokenizer strBuilder_StrBuilderTokenizer = arg0.new StrBuilderTokenizer();
        String content = strBuilder_StrBuilderTokenizer.getContent();
        assertEquals(32, arg0.capacity());
        assertEquals("", content);
        assertNotNull(content);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesStrBuilderTokenizerTakingStrBuilder() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        StrBuilder.StrBuilderTokenizer strBuilder_StrBuilderTokenizer = arg0.new StrBuilderTokenizer();
        // Undeclared exception!
        try { 
          strBuilder_StrBuilderTokenizer.previous();
          fail("Expecting exception: NoSuchElementException");
        
        } catch(NoSuchElementException e) {
           //
           // no message in exception (getMessage() returned null)
           //
           verifyException("org.apache.commons.lang3.text.StrTokenizer", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubstringTakingIntThrowsStringIndexOutOfBoundsException() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        // Undeclared exception!
        try { 
          strBuilder.substring(351);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // end < start
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubstringTaking2ArgumentsThrowsStringIndexOutOfBoundsException() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        // Undeclared exception!
        try { 
          strBuilder.substring((-1038), 1);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // String index out of range: -1038
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsTakingObjectReturningFalse() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        boolean equals = strBuilder.equals((Object) "");
        assertFalse(equals);
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesStrBuilderTakingStringAndCallsEqualsTakingStrBuilder() throws Throwable  {
        StrBuilder arg0 = new StrBuilder("})+ovSBG");
        StrBuilder strBuilder = new StrBuilder("Vi3F+)xF");
        boolean equals = strBuilder.equals(arg0);
        assertEquals(8, strBuilder.length());
        assertEquals(40, strBuilder.capacity());
        assertFalse(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsTakingStrBuilder() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder arg0 = new StrBuilder("2<pIYEKt&6?");
        boolean equals = strBuilder.equals(arg0);
        assertEquals(43, arg0.capacity());
        assertFalse(equals);
        assertEquals(32, strBuilder.capacity());
        assertEquals(11, arg0.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsTakingObjectReturningTrue() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        boolean equals = arg0.equals((Object) arg0);
        assertTrue(equals);
        assertEquals(32, arg0.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsTakingStrBuilderReturningTrue() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("#i[)N@ {jVv+BU");
        StrBuilder arg0 = new StrBuilder("#i[)N@ {jVv+BU");
        boolean equals = strBuilder.equals(arg0);
        assertEquals(14, arg0.size());
        assertTrue(equals);
        assertEquals(46, arg0.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendlnTakingFloat() throws Throwable  {
        StrBuilder arg0 = new StrBuilder(" 6$BZ|+H^D(bV");
        StrBuilder strBuilder = new StrBuilder(" 6$BZ|+H^D(bV");
        strBuilder.appendln(662.269F);
        boolean equalsIgnoreCase = strBuilder.equalsIgnoreCase(arg0);
        assertEquals(21, strBuilder.size());
        assertFalse(equalsIgnoreCase);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesStrBuilderTakingStringAndCallsEqualsIgnoreCase0() throws Throwable  {
        StrBuilder arg0 = new StrBuilder(" 6$BZ|+;^O(bV");
        boolean equalsIgnoreCase = arg0.equalsIgnoreCase(arg0);
        assertEquals(13, arg0.length());
        assertEquals(45, arg0.capacity());
        assertTrue(equalsIgnoreCase);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesStrBuilderTakingStringAndCallsEqualsIgnoreCase1() throws Throwable  {
        StrBuilder arg0 = new StrBuilder(" 6$BZ|+H^D(bV");
        StrBuilder strBuilder = new StrBuilder(" 6$BZ|+H^D(bV");
        boolean equalsIgnoreCase = strBuilder.equalsIgnoreCase(arg0);
        assertEquals(45, strBuilder.capacity());
        assertEquals(13, strBuilder.length());
        assertTrue(equalsIgnoreCase);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTakingStrMatcherReturningNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("a3@eufUU9z*5;r!n3{");
        StrMatcher arg0 = StrMatcher.tabMatcher();
        int lastIndexOf = strBuilder.lastIndexOf(arg0);
        assertEquals((-1), lastIndexOf);
        assertEquals(50, strBuilder.capacity());
        assertEquals(18, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesStrBuilderTakingIntAndCallsLastIndexOfTaking1And1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(1);
        StrMatcher arg0 = StrMatcher.singleQuoteMatcher();
        int lastIndexOf = strBuilder.lastIndexOf(arg0, 1);
        assertEquals(1, strBuilder.capacity());
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1WithNullAndNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        int lastIndexOf = strBuilder.lastIndexOf((StrMatcher) null, (-860));
        assertEquals(32, strBuilder.capacity());
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTakingStringReturningNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("JAVA__9");
        int lastIndexOf = strBuilder.lastIndexOf("JAV}__9");
        assertEquals(39, strBuilder.capacity());
        assertEquals((-1), lastIndexOf);
        assertEquals(7, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTakingStringReturningZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("JAVA_0_9");
        int lastIndexOf = strBuilder.lastIndexOf("JAVA_0_9");
        assertEquals(40, strBuilder.capacity());
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1WithZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("V|");
        int lastIndexOf = strBuilder.lastIndexOf("JAVA_1_5", 0);
        assertEquals((-1), lastIndexOf);
        assertEquals(2, strBuilder.length());
        assertEquals(34, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1WithNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(7);
        int lastIndexOf = strBuilder.lastIndexOf("", (-32768));
        assertEquals(7, strBuilder.capacity());
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1WithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        int lastIndexOf = strBuilder.lastIndexOf((String) null, 102);
        assertEquals(32, strBuilder.capacity());
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1AndCreatesStrBuilderTakingStringAndLastIndexOfTaking1And1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(" 6$BZ|+H^D(bV");
        int lastIndexOf = strBuilder.lastIndexOf("_", 5401);
        assertEquals(45, strBuilder.capacity());
        assertEquals((-1), lastIndexOf);
        assertEquals(13, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1WithDigit() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        int lastIndexOf = strBuilder.lastIndexOf('3', 44);
        assertEquals(32, strBuilder.capacity());
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndLastIndexOfTaking1And11() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("<#j[s7HF");
        int lastIndexOf = strBuilder.lastIndexOf('[', 1160);
        assertEquals(40, strBuilder.capacity());
        assertEquals(8, strBuilder.size());
        assertEquals(3, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1WithZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("V|");
        StrMatcher.CharMatcher arg0 = new StrMatcher.CharMatcher('%');
        int indexOf = strBuilder.indexOf((StrMatcher) arg0, 0);
        assertEquals(34, strBuilder.capacity());
        assertEquals(2, strBuilder.length());
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1WithNullAndPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        int indexOf = strBuilder.indexOf((StrMatcher) null, 1801);
        assertEquals((-1), indexOf);
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And10() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(")Y )G\"~Ws\"UM{Q`");
        StrMatcher.CharMatcher arg0 = new StrMatcher.CharMatcher(' ');
        int indexOf = strBuilder.indexOf((StrMatcher) arg0, (-633));
        assertEquals(2, indexOf);
        assertEquals(15, strBuilder.size());
        assertEquals(47, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("}GtF=_=?3;");
        int indexOf = strBuilder.indexOf("6.1", (-2471));
        assertEquals(10, strBuilder.length());
        assertEquals(42, strBuilder.capacity());
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And11() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("Zz}OUl~/%ud^ZNsAH@");
        int indexOf = strBuilder.indexOf("", 5);
        assertEquals(18, strBuilder.length());
        assertEquals(50, strBuilder.capacity());
        assertEquals(5, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndCreatesStrBuilderTakingStringAndIndexOfTaking1And1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("java.vm.name");
        int indexOf = strBuilder.indexOf("java.vm.name", (-599));
        assertEquals(0, indexOf);
        assertEquals(44, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1WithPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(" 6$BZ|+H^D(bV");
        int indexOf = strBuilder.indexOf("]", 4);
        assertEquals((-1), indexOf);
        assertEquals(13, strBuilder.size());
        assertEquals(45, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTakingStrMatcherReturningTrue() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("V|");
        StrMatcher arg0 = StrMatcher.charSetMatcher("V|");
        boolean contains = strBuilder.contains(arg0);
        assertEquals(2, strBuilder.length());
        assertTrue(contains);
        assertEquals(34, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTakingStrMatcherReturningFalse() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrMatcher arg0 = StrMatcher.noneMatcher();
        boolean contains = strBuilder.contains(arg0);
        assertEquals(32, strBuilder.capacity());
        assertFalse(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTakingStringReturningTrue() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("java.vendor.url");
        boolean contains = strBuilder.contains("java.vendor.url");
        assertEquals(47, strBuilder.capacity());
        assertTrue(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTakingStringReturningFalse() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        boolean contains = strBuilder.contains("");
        assertFalse(contains);
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTakingChar() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(" 6$BZ|+H^D(bV");
        boolean contains = strBuilder.contains('`');
        assertEquals(13, strBuilder.length());
        assertFalse(contains);
        assertEquals(45, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testMidStringReturningEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.midString(115, 32);
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testMidStringWithNegativeAndMidStringReturningEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("<#j[s7HF");
        strBuilder.midString((-506), (-506));
        assertEquals(8, strBuilder.length());
        assertEquals(40, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testMidStringWithNegativeAndMidStringReturningNonEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("<#D`[s7HF");
        String midString = strBuilder.midString((-1023), 97);
        assertEquals("<#D`[s7HF", midString);
        assertEquals(41, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testMidString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("}GtF=_=?3;");
        String midString = strBuilder.midString(2, 2);
        assertEquals("tF", midString);
        assertEquals(42, strBuilder.capacity());
        assertEquals(10, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRightStringReturningNonEmptyString() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        StrBuilder append = arg0.append("...", 1, 1);
        StrBuilder appendln = append.appendln(arg0);
        String rightString = appendln.rightString(1);
        assertEquals(3, arg0.length());
        assertEquals("\n", rightString);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRightStringWithNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.rightString((-1019));
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRightString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(3574);
        String rightString = strBuilder.rightString(42);
        assertEquals("", rightString);
        assertEquals(3574, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLeftString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        String leftString = strBuilder.leftString(13);
        assertEquals("", leftString);
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLeftStringWithNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder((-2370));
        strBuilder.leftString((-2370));
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLeftStringReturningNonEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(" 6$BZ|+H^D(bV");
        String leftString = strBuilder.leftString(6);
        assertEquals(" 6$BZ|", leftString);
        assertEquals(13, strBuilder.size());
        assertEquals(45, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubSequenceWithPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        // Undeclared exception!
        try { 
          strBuilder.subSequence(1, (-1));
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // String index out of range: -2
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubSequenceReturningCharSequenceWhereLengthIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        CharSequence subSequence = strBuilder.subSequence(0, 0);
        assertEquals(32, strBuilder.capacity());
        assertEquals("", subSequence);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubSequenceWithNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        // Undeclared exception!
        try { 
          strBuilder.subSequence((-2043), (-2043));
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // String index out of range: -2043
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubSequenceThrowsStringIndexOutOfBoundsException() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("'Rd~CHa$");
        // Undeclared exception!
        try { 
          strBuilder.subSequence(0, 46);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // String index out of range: 46
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesStrBuilderTakingStringAndCallsEndsWith() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("Zz}OUl~/%ud^2ZNsAH@");
        boolean endsWith = strBuilder.endsWith("java.vendor.url");
        assertFalse(endsWith);
        assertEquals(19, strBuilder.length());
        assertEquals(51, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesStrBuilderTakingNoArgumentsAndCallsEndsWith() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        boolean endsWith = strBuilder.endsWith("xr5c`1uO+LVK_/[");
        assertFalse(endsWith);
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEndsWithWithEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        boolean endsWith = strBuilder.endsWith("");
        assertTrue(endsWith);
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEndsWithWithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        boolean endsWith = strBuilder.endsWith((String) null);
        assertEquals(32, strBuilder.capacity());
        assertFalse(endsWith);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEndsWithReturningTrue() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("'23QhE?sJ.b#?f#");
        boolean endsWith = strBuilder.endsWith("'23QhE?sJ.b#?f#");
        assertEquals(47, strBuilder.capacity());
        assertTrue(endsWith);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testStartsWithReturningFalse() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        boolean startsWith = strBuilder.startsWith("oHIQ\"%?");
        assertFalse(startsWith);
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testStartsWithWithEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(97);
        boolean startsWith = strBuilder.startsWith("");
        assertEquals(97, strBuilder.capacity());
        assertTrue(startsWith);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testStartsWithWithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder((-786));
        boolean startsWith = strBuilder.startsWith((String) null);
        assertFalse(startsWith);
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testStartsWithReturningTrue() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("`=,jB");
        boolean startsWith = strBuilder.startsWith("`=,jB");
        assertTrue(startsWith);
        assertEquals(38, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendlnTakingStringBuffer() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StringBuffer arg0 = new StringBuffer();
        strBuilder.appendln(arg0);
        assertEquals(1, strBuilder.size());
        
        strBuilder.trim();
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder reverse = strBuilder.reverse();
        assertEquals(32, reverse.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(">6,-H~ll$cUmo");
        StrBuilder reverse = strBuilder.reverse();
        assertEquals(46, reverse.capacity());
        assertEquals(14, reverse.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteAllTakingStrMatcherReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder appendln = strBuilder.appendln((-531));
        StrMatcher.TrimMatcher arg0 = new StrMatcher.TrimMatcher();
        appendln.deleteAll((StrMatcher) arg0);
        assertEquals(4, appendln.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReplaceFirstTaking2Strings() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("#i[)N@ {jVv+BU");
        strBuilder.replaceFirst("#i[)N@ {jVv+BU", "");
        assertEquals(0, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReplaceFirstTaking2StringsReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("u:bBPxM9>qGJ");
        StrBuilder replaceFirst = strBuilder.replaceFirst("iStn&[Dx}1['$6)Lfs", "iStn&[Dx}1['$6)Lfs");
        assertEquals(45, replaceFirst.capacity());
        assertEquals(13, replaceFirst.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReplaceAllTaking2Strings() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder replaceAll = strBuilder.replaceAll("Mac", (String) null);
        assertEquals(32, replaceAll.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReplaceAllTaking2StringsWithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder replaceAll = strBuilder.replaceAll((String) null, (String) null);
        assertEquals(32, replaceAll.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesStrBuilderTakingNoArgumentsAndCallsReplaceFirstTaking2Chars0() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder replaceFirst = strBuilder.replaceFirst('K', 'n');
        assertEquals(32, replaceFirst.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReplaceFirstTaking2CharsReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("y6$B0|+},D(bV");
        StrBuilder replaceFirst = strBuilder.replaceFirst('$', 'E');
        assertEquals(45, replaceFirst.capacity());
        assertEquals(13, replaceFirst.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesStrBuilderTakingNoArgumentsAndCallsReplaceFirstTaking2Chars1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder replaceFirst = strBuilder.replaceFirst('Y', 'Y');
        assertEquals(32, replaceFirst.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReplaceAllTaking2CharsReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(" 6$BZ|+H^D(bV");
        StrBuilder replaceAll = strBuilder.replaceAll(' ', ',');
        assertEquals(13, replaceAll.length());
        assertEquals(45, replaceAll.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReplaceAllTaking2CharsReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder replaceAll = strBuilder.replaceAll('*', '*');
        assertEquals(32, replaceAll.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReplaceTaking3ArgumentsReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(1);
        StrBuilder replace = strBuilder.replace(0, 94, (String) null);
        assertEquals(1, replace.capacity());
        assertTrue(replace.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReplaceTaking3ArgumentsReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("JAVA_0_9");
        strBuilder.replace(0, 0, "JAVA_0_9");
        assertEquals(16, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReplaceFirstTaking2StringsWithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(" 6$BZ|+H^D(bV");
        strBuilder.replaceFirst(" 6$BZ|+H^D(bV", (String) null);
        assertEquals(0, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReplaceAllTaking2StringsReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("JAVA_1_8");
        StrBuilder replaceAll = strBuilder.replaceAll("JAVA_1_8", "JAVA_1_8");
        assertEquals(40, replaceAll.capacity());
        assertEquals(8, replaceAll.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteFirstTakingStringWithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder deleteFirst = strBuilder.deleteFirst((String) null);
        assertEquals(32, deleteFirst.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteFirstTakingString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("W");
        assertEquals(1, strBuilder.length());
        
        strBuilder.deleteFirst("W");
        assertEquals(0, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteAllTakingStringWithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder deleteAll = strBuilder.deleteAll((String) null);
        assertEquals(32, deleteAll.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteFirstTakingChar() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("x}tz_Etl+`");
        StrBuilder deleteFirst = strBuilder.deleteFirst('p');
        assertEquals(42, deleteFirst.capacity());
        assertEquals(10, deleteFirst.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteAllTakingChar() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        arg0.appendFixedWidthPadRight((Object) arg0, 97, 'J');
        arg0.deleteAll('J');
        assertFalse(arg0.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testTrimReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("[] ");
        assertEquals(3, strBuilder.size());
        
        strBuilder.trim();
        assertEquals(2, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder delete = strBuilder.delete(0, 95);
        assertEquals(32, delete.capacity());
        assertEquals(0, delete.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking1And1WithTrue() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.insert(0, true);
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking4Arguments() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] arg1 = new char[0];
        StrBuilder insert = strBuilder.insert(0, arg1, 0, 0);
        assertEquals(32, insert.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking4ArgumentsWithPositiveAndZero0() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] arg1 = new char[0];
        // Undeclared exception!
        try { 
          strBuilder.insert(0, arg1, 0, 2200);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // Invalid length: 2200
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking4ArgumentsWithNegativeAndZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] arg1 = new char[0];
        // Undeclared exception!
        try { 
          strBuilder.insert(0, arg1, 0, (-3195));
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // Invalid length: -3195
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking4ArgumentsWithPositiveAndZero1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] arg1 = new char[0];
        // Undeclared exception!
        try { 
          strBuilder.insert(0, arg1, 32, 0);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // Invalid offset: 32
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking4ArgumentsWithNegativeAndNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] arg1 = new char[0];
        // Undeclared exception!
        try { 
          strBuilder.insert(0, arg1, (-128), (-128));
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // Invalid offset: -128
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking4ArgumentsWithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder insert = strBuilder.insert(0, (char[]) null, 0, 692);
        assertEquals(32, insert.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking4ArgumentsReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("'Rd~CHa$");
        char[] arg1 = new char[9];
        strBuilder.insert(4, arg1, 4, 4);
        assertEquals(12, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking1And1ReturningStrBuilderWhereSizeIsPositiveAndInsertTaking1And1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] arg1 = new char[3];
        strBuilder.insert(0, arg1);
        assertEquals(3, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking1And1WithEmptyArray() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] arg1 = new char[0];
        StrBuilder insert = strBuilder.insert(0, arg1);
        assertEquals(32, insert.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking1And1ReturningStrBuilderWhereSizeIsZeroAndCreatesStrBuilderTakingString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("");
        StrBuilder insert = strBuilder.insert(0, "");
        assertEquals(32, insert.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking1And1ReturningStrBuilderWhereSizeIsZeroAndCreatesStrBuilderTakingNoArguments() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder insert = strBuilder.insert(0, (Object) null);
        assertEquals(32, insert.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking1And1ThrowsStringIndexOutOfBoundsExceptionAndInsertTaking1And10() throws Throwable  {
        StrBuilder arg1 = new StrBuilder();
        // Undeclared exception!
        try { 
          arg1.insert((-3921), (Object) arg1);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // String index out of range: -3921
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendFixedWidthPadRightTaking11And1WithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(1012);
        strBuilder.appendFixedWidthPadRight((Object) null, 1012, 's');
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendFixedWidthPadRightTaking11And1ReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        StrBuilder appendFixedWidthPadRight = arg0.appendFixedWidthPadRight((Object) arg0, 0, '+');
        assertEquals(32, appendFixedWidthPadRight.capacity());
        assertEquals(0, appendFixedWidthPadRight.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendPadding() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder appendPadding = strBuilder.appendPadding((-764), 'D');
        assertEquals(32, appendPadding.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendSeparatorTaking1And1ReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder appendSeparator = strBuilder.appendSeparator('u', (-1417));
        assertEquals(32, appendSeparator.capacity());
        assertEquals(0, appendSeparator.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendSeparatorTaking1And1WithEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder appendSeparator = strBuilder.appendSeparator("", (-783));
        assertEquals(32, appendSeparator.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendSeparatorTaking1And1WithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder appendSeparator = strBuilder.appendSeparator((String) null, (-301));
        assertEquals(32, appendSeparator.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendSeparatorTakingCharReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("UA'Pc8o'JyE'VYJ#");
        strBuilder.appendSeparator('p');
        assertEquals(17, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendSeparatorTakingStringReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(3574);
        StrBuilder appendSeparator = strBuilder.appendSeparator('W', 3124);
        appendSeparator.appendSeparator("");
        assertEquals(1, strBuilder.size());
        assertEquals(1, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendWithSeparatorsTaking1And1ReturningStrBuilderWhereSizeIsPositive0() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        Locale.FilteringMode arg2 = Locale.FilteringMode.IGNORE_EXTENDED_RANGES;
        Locale.FilteringMode arg3 = Locale.FilteringMode.EXTENDED_FILTERING;
        EnumSet<Locale.FilteringMode> of = EnumSet.of(arg2, arg2, arg2, arg3);
        Iterator<Locale.FilteringMode> arg0 = of.iterator();
        strBuilder.appendWithSeparators(arg0, "Invalid offset: ");
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendWithSeparatorsTaking1And1WithNullAndEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder appendWithSeparators = strBuilder.appendWithSeparators((Iterator<?>) null, "");
        assertEquals(32, appendWithSeparators.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendWithSeparatorsTaking1And1ReturningStrBuilderWhereSizeIsPositive1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        Locale.FilteringMode arg1 = Locale.FilteringMode.MAP_EXTENDED_RANGES;
        Locale.FilteringMode arg4 = Locale.FilteringMode.IGNORE_EXTENDED_RANGES;
        EnumSet<Locale.FilteringMode> arg0 = EnumSet.of(arg1, arg1, arg4, arg4, arg4);
        strBuilder.appendWithSeparators((Iterable<?>) arg0, "Pi_7?b^$bX7^,");
        assertEquals(109, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendWithSeparatorsTaking1And1ReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder appendWithSeparators = strBuilder.appendWithSeparators((Iterable<?>) null, "");
        assertEquals(32, appendWithSeparators.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTakingStringReturningZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(32);
        Object[] arg0 = new Object[2];
        StrBuilder appendWithSeparators = strBuilder.appendWithSeparators(arg0, "");
        int indexOf = appendWithSeparators.indexOf("");
        assertEquals(27, strBuilder.size());
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendWithSeparatorsTaking1And1WithEmptyArray() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        Object[] arg0 = new Object[0];
        StrBuilder appendWithSeparators = strBuilder.appendWithSeparators(arg0, "2%!");
        assertEquals(32, appendWithSeparators.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendWithSeparatorsTaking1And1WithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder appendWithSeparators = strBuilder.appendWithSeparators((Object[]) null, "u:G`h|");
        assertEquals(32, appendWithSeparators.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendAllTakingIteratorReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        Locale.FilteringMode arg2 = Locale.FilteringMode.REJECT_EXTENDED_RANGES;
        EnumSet<Locale.FilteringMode> of = EnumSet.of(arg2, arg2, arg2);
        Iterator<Locale.FilteringMode> arg0 = of.iterator();
        strBuilder.appendAll(arg0);
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendAllTakingIteratorWithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder appendAll = strBuilder.appendAll((Iterator<?>) null);
        assertEquals(32, appendAll.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendAllTakingIterable() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder appendAll = strBuilder.appendAll((Iterable<?>) null);
        assertEquals(32, appendAll.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendAllTakingObjectArray() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder[] arg0 = new StrBuilder[2];
        StrBuilder appendAll = strBuilder.appendAll(arg0);
        assertEquals(32, appendAll.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendAllTakingObjectArrayWithEmptyArray() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        Locale.FilteringMode[] arg0 = new Locale.FilteringMode[0];
        StrBuilder appendAll = strBuilder.appendAll(arg0);
        assertEquals(32, appendAll.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendAllTakingObjectArrayWithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder appendAll = strBuilder.appendAll((StrBuilder[]) null);
        assertEquals(32, appendAll.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingBooleanWithFalse() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.append(false);
        assertEquals(5, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsReturningStrBuilderWhereSizeIsPositiveAndAppendTaking1And2Ints2() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] arg0 = new char[3];
        strBuilder.append(arg0, 1, 1);
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsWithPositiveAndAppendTaking1And2IntsThrowsStringIndexOutOfBoundsException1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] arg0 = new char[0];
        // Undeclared exception!
        try { 
          strBuilder.append(arg0, 0, 24);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // Invalid length: 24
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsWithNonEmptyArray() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(0);
        char[] arg0 = new char[1];
        // Undeclared exception!
        try { 
          strBuilder.append(arg0, 0, (-1939));
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // Invalid length: -1939
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsWithNegativeAndAppendTaking1And2IntsThrowsStringIndexOutOfBoundsException0() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] arg0 = new char[0];
        // Undeclared exception!
        try { 
          strBuilder.append(arg0, (-2233), (-2233));
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // Invalid startIndex: -2233
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingCharArrayWithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder((String) null);
        StrBuilder append = strBuilder.append((char[]) null);
        assertEquals(32, append.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsWithZeroAndAppendTaking1And2IntsAndAppendTaking1And2Ints1() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        StrBuilder append = arg0.append(arg0, 0, 0);
        assertEquals(0, append.length());
        assertEquals(32, append.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsWithZero() throws Throwable  {
        StrBuilder arg0 = new StrBuilder(0);
        // Undeclared exception!
        try { 
          arg0.append(arg0, 0, 9);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // length must be valid
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsWithNegativeAndCreatesStrBuilderTakingInt() throws Throwable  {
        StrBuilder arg0 = new StrBuilder((-532));
        // Undeclared exception!
        try { 
          arg0.append(arg0, 0, (-532));
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // length must be valid
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsWithNegativeAndAppendTaking1And2IntsWithPositiveAndAppendTaking1And2IntsThrowsStringIndexOutOfBoundsException() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        // Undeclared exception!
        try { 
          arg0.append(arg0, (-3356), 9);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // startIndex must be valid
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsWithNullAndAppendTaking1And2IntsAndAppendTaking1And2Ints0() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder append = strBuilder.append((StrBuilder) null, 1053, 1053);
        assertEquals(32, append.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingStrBuilderReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder arg0 = new StrBuilder("Index: ");
        strBuilder.append(arg0);
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingStrBuilderWithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder append = strBuilder.append((StrBuilder) null);
        assertEquals(32, append.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendlnTaking1And2IntsThrowsStringIndexOutOfBoundsException() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StringBuilder arg0 = new StringBuilder(98);
        // Undeclared exception!
        try { 
          strBuilder.appendln(arg0, 0, 98);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // length must be valid
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsThrowsStringIndexOutOfBoundsException0() throws Throwable  {
        StringBuilder arg0 = new StringBuilder();
        StrBuilder strBuilder = new StrBuilder((-2048));
        // Undeclared exception!
        try { 
          strBuilder.append(arg0, 337, (-2048));
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // startIndex must be valid
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsWithNegativeAndAppendTaking1And2IntsThrowsStringIndexOutOfBoundsException1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StringBuilder arg0 = new StringBuilder();
        // Undeclared exception!
        try { 
          strBuilder.append(arg0, (-2048), (-2048));
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // startIndex must be valid
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsThrowsStringIndexOutOfBoundsException1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder((-403));
        StringBuilder arg0 = new StringBuilder((CharSequence) "JAVA__9");
        // Undeclared exception!
        try { 
          strBuilder.append(arg0, 2, (-2350));
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // length must be valid
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingStringBuilder() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StringBuilder arg0 = new StringBuilder("org.apache.commons.lang3.ArrayUtils");
        StrBuilder append = strBuilder.append(arg0);
        int lastIndexOf = append.lastIndexOf("h8yY*cn2kijSOWI_", 1441);
        assertEquals(70, strBuilder.capacity());
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingStringBuilderWithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("org.apache.commons.lang3.text.StrBuilder$StrBuilderTokenizer");
        StrBuilder append = strBuilder.append((StringBuilder) null);
        assertEquals(92, append.capacity());
        assertEquals(60, append.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsThrowsStringIndexOutOfBoundsExceptionAndAppendTaking1And2Ints0() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StringBuffer arg0 = new StringBuffer("org.apache.commons.lang3.text.StrBuilder$StrBuilderTokenizer");
        // Undeclared exception!
        try { 
          strBuilder.append(arg0, 34, 34);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // length must be valid
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsWithNegativeAndPositive0() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StringBuffer arg0 = new StringBuffer("2<pIYEKt&6?");
        // Undeclared exception!
        try { 
          strBuilder.append(arg0, 2, (-1));
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // length must be valid
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsWithStringBufferWhereLengthIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StringBuffer arg0 = new StringBuffer(1277);
        // Undeclared exception!
        try { 
          strBuilder.append(arg0, 1277, 1277);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // startIndex must be valid
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsWithNegativeAndPositive1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StringBuffer arg0 = new StringBuffer("xv}:.P$=)M2PA");
        // Undeclared exception!
        try { 
          strBuilder.append(arg0, (-872), 1230);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // startIndex must be valid
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder append = strBuilder.append((StringBuffer) null, (-179), (-179));
        assertEquals(32, append.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsAndCreatesStrBuilderTakingNoArgumentsAndAppendTaking1And2Ints() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder append = strBuilder.append("%", 0, 0);
        assertEquals(32, append.capacity());
        assertTrue(append.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsThrowsStringIndexOutOfBoundsExceptionAndAppendTaking1And2Ints1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        // Undeclared exception!
        try { 
          strBuilder.append("y=?I>Lk&?@", 0, 1506);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // length must be valid
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsWithNegativeAndAppendTaking1And2IntsThrowsStringIndexOutOfBoundsException2() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        // Undeclared exception!
        try { 
          strBuilder.append("Drn1':t+B).", 5, (-850));
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // length must be valid
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsWithPositiveAndAppendTaking1And2IntsThrowsStringIndexOutOfBoundsException2() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("'Rd~CHa$");
        // Undeclared exception!
        try { 
          strBuilder.append("'Rd~CHa$", 2817, 2817);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // startIndex must be valid
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsWithEmptyStringAndNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder((-786));
        // Undeclared exception!
        try { 
          strBuilder.append("", (-481), 0);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // startIndex must be valid
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsWithNullAndAppendTaking1And2IntsAndAppendTaking1And2Ints1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder append = strBuilder.append((String) null, 3755, 3755);
        assertEquals(32, append.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingStringWithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder append = strBuilder.append((String) null);
        assertEquals(32, append.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesStrBuilderTakingIntAndCallsAppendTaking1And2Ints() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(3574);
        StrBuilder append = strBuilder.append((CharSequence) null, 3574, 3574);
        assertEquals(3574, append.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking1And2IntsReturningStrBuilderWhereSizeIsPositiveAndAppendTaking1And2Ints3() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("Cannot get the toString of a null identity");
        strBuilder.append((CharSequence) "Cannot get the toString of a null identity", 12, 12);
        assertEquals(54, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingCharSequenceReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder append = strBuilder.append((CharSequence) null);
        assertEquals(32, append.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingCharSequenceReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("=K-e}it/[`}");
        strBuilder.append((CharSequence) "=K-e}it/[`}");
        assertEquals(22, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendNullReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder setNullText = strBuilder.setNullText("CQ*>Y m]p-J~z");
        setNullText.appendNull();
        assertFalse(setNullText.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendNewLineAndSetNewLineText() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(" 6$BZ|+H^D(bV");
        strBuilder.setNewLineText("%IN5/O");
        strBuilder.appendNewLine();
        assertEquals(19, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetCharsTaking4ArgumentsThrowsStringIndexOutOfBoundsException() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.appendFixedWidthPadRight((Object) "org.apache.commons.lang3.text.StrTokenizer", 32, 'J');
        char[] arg2 = new char[3];
        // Undeclared exception!
        try { 
          strBuilder.getChars(1154, 32, arg2, 32);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // end < start
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendlnTaking1And2IntsAndCreatesStrBuilderTakingStringAndAppendTakingObject() throws Throwable  {
        StrBuilder arg0 = new StrBuilder("&>vzPe)6='hz3");
        arg0.append((Object) "&>vzPe)6='hz3");
        arg0.appendln(arg0, 16, 16);
        assertEquals(112, arg0.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetCharsTaking4ArgumentsWithNegativeAndNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] arg2 = new char[1];
        // Undeclared exception!
        try { 
          strBuilder.getChars(755, (-4061), arg2, (-4061));
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // String index out of range: -4061
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetCharsTaking4ArgumentsWithNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        // Undeclared exception!
        try { 
          strBuilder.getChars((-650), (-701), (char[]) null, 1342);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // String index out of range: -650
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetCharsTaking4ArgumentsWithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        // Undeclared exception!
        try { 
          strBuilder.getChars(1354, 1354, (char[]) null, 1354);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // String index out of range: 1354
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetCharsTakingCharArrayReturningNonEmptyArray() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] arg0 = new char[0];
        strBuilder.insert(0, false);
        strBuilder.getChars(arg0);
        assertEquals(5, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetCharsTakingCharArrayReturningEmptyArray() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] chars = strBuilder.getChars((char[]) null);
        assertEquals(0, chars.length);
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToCharArrayTaking2ArgumentsReturningEmptyArray() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] charArray = strBuilder.toCharArray(0, 0);
        assertEquals(32, strBuilder.capacity());
        assertEquals(0, charArray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToCharArrayTakingNoArgumentsReturningEmptyArray() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.toCharArray();
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToCharArrayTakingNoArgumentsReturningNonEmptyArray() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("JD");
        char[] charArray = strBuilder.toCharArray();
        assertEquals(34, strBuilder.capacity());
        assertEquals(2, charArray.length);
        assertArrayEquals(new char[] {'J', 'D'}, charArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteCharAtReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        arg0.appendFixedWidthPadRight((Object) arg0, 97, 'J');
        arg0.deleteCharAt(1);
        assertFalse(arg0.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteCharAtThrowsStringIndexOutOfBoundsException() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        // Undeclared exception!
        try { 
          strBuilder.deleteCharAt(2106);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // String index out of range: 2106
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteCharAtWithNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        // Undeclared exception!
        try { 
          strBuilder.deleteCharAt((-1));
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // String index out of range: -1
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetCharAtWithPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        // Undeclared exception!
        try { 
          strBuilder.setCharAt(31, 'y');
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // String index out of range: 31
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetCharAt() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("<#j[s7HF");
        StrBuilder setCharAt = strBuilder.setCharAt(0, 'R');
        assertEquals(8, strBuilder.length());
        assertEquals(40, setCharAt.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetCharAtWithNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        // Undeclared exception!
        try { 
          strBuilder.setCharAt((-1753), 'u');
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // String index out of range: -1753
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCharAtThrowsStringIndexOutOfBoundsException() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        // Undeclared exception!
        try { 
          strBuilder.charAt(90);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // String index out of range: 90
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCharAtWithNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        // Undeclared exception!
        try { 
          strBuilder.charAt((-547));
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // String index out of range: -547
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendSeparatorTaking2StringsReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        StrBuilder appendFixedWidthPadRight = arg0.appendFixedWidthPadRight((Object) arg0, 68, 'J');
        appendFixedWidthPadRight.appendSeparator((String) null, "4.1");
        assertEquals(68, arg0.length());
        assertEquals(136, arg0.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testClearReturningStrBuilderWhereCapacityIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder((-1171));
        assertEquals(32, strBuilder.capacity());
        
        strBuilder.minimizeCapacity();
        strBuilder.clear();
        assertEquals(0, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetLengthReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.setLength(2070);
        strBuilder.setLength(1734);
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetLengthThrowsStringIndexOutOfBoundsException() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        // Undeclared exception!
        try { 
          strBuilder.setLength((-128));
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // String index out of range: -128
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetLengthReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder setLength = strBuilder.setLength(0);
        assertEquals(32, setLength.capacity());
        assertEquals(0, setLength.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendFixedWidthPadRightTaking11And1WithDigit() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("java.vendor.url");
        strBuilder.setNullText("java.vendor.url");
        strBuilder.appendFixedWidthPadRight((Object) null, 10, '3');
        assertEquals(25, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetNullTextWithNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder setNullText = strBuilder.setNullText((String) null);
        assertEquals(32, setNullText.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testWriteTakingInt() throws Throwable  {
        StrBuilder arg0 = new StrBuilder((-786));
        StrBuilder.StrBuilderWriter strBuilder_StrBuilderWriter = arg0.new StrBuilderWriter();
        strBuilder_StrBuilderWriter.write((-786));
        assertEquals(1, arg0.length());
        assertEquals(32, arg0.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testWriteTakingString() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        StrBuilder.StrBuilderWriter strBuilder_StrBuilderWriter = arg0.new StrBuilderWriter();
        strBuilder_StrBuilderWriter.write("");
        assertEquals(32, arg0.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testWriteTaking3Arguments() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        StrBuilder.StrBuilderWriter strBuilder_StrBuilderWriter = arg0.new StrBuilderWriter();
        strBuilder_StrBuilderWriter.write("java.vm.specification.version", 4, 4);
        assertFalse(arg0.isEmpty());
        assertEquals(4, arg0.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloseAndCreatesStrBuilderTakingNoArgumentsAndCreatesStrBuilderWriterTakingStrBuilder() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        StrBuilder.StrBuilderWriter strBuilder_StrBuilderWriter = arg0.new StrBuilderWriter();
        strBuilder_StrBuilderWriter.close();
        assertEquals(32, arg0.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testFlush() throws Throwable  {
        StrBuilder arg0 = new StrBuilder("java.vm.name");
        StrBuilder.StrBuilderWriter strBuilder_StrBuilderWriter = arg0.new StrBuilderWriter();
        strBuilder_StrBuilderWriter.flush();
        assertEquals(44, arg0.capacity());
        assertEquals(12, arg0.length());
        assertFalse(arg0.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubstringTakingIntReturningNonEmptyString() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        arg0.appendln(arg0);
        arg0.substring(0);
        assertEquals(1, arg0.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTakingStrMatcherReturningZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(" 6$BZ|+H^D(bV");
        StrMatcher arg0 = StrMatcher.trimMatcher();
        int indexOf = strBuilder.indexOf(arg0);
        assertEquals(13, strBuilder.length());
        assertEquals(45, strBuilder.capacity());
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking1And1ThrowsStringIndexOutOfBoundsExceptionAndInsertTaking1And11() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        // Undeclared exception!
        try { 
          strBuilder.insert(5, 710L);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // String index out of range: 5
           //
           verifyException("org.apache.commons.lang3.text.StrBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAsWriter() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("'Rd~CHa$");
        strBuilder.asWriter();
        assertEquals(8, strBuilder.length());
        assertEquals(40, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendlnTakingString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.appendln("Fu");
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendlnTaking1And2IntsAndAppendlnTaking1And2Ints0() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        char[] arg0 = new char[0];
        strBuilder.appendln(arg0, 0, 0);
        assertEquals(1, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendlnTakingLong() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(1);
        strBuilder.appendln((long) 1);
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendFixedWidthPadRightTaking2IntsAnd1ReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.appendFixedWidthPadRight(1, 1, 'Z');
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendlnTaking1And2IntsAndAppendlnTaking1And2Ints1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StringBuffer arg0 = new StringBuffer();
        strBuilder.appendln(arg0, 0, 0);
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTakingCharReturningNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("V|");
        int lastIndexOf = strBuilder.lastIndexOf('T');
        assertEquals(34, strBuilder.capacity());
        assertEquals(2, strBuilder.length());
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToStringBuilder() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StringBuilder stringBuilder = strBuilder.toStringBuilder();
        assertEquals(32, strBuilder.capacity());
        assertEquals("", stringBuilder.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendlnTakingChar() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.appendln('J');
        assertEquals(2, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToCharArrayTaking2ArgumentsReturningNonEmptyArray() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.appendln((double) 0);
        strBuilder.toCharArray(2, 80);
        assertEquals(4, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendlnTaking1And2IntsAndAppendlnTaking1And2Ints2() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.appendln((StringBuilder) null, 490, 490);
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking1And1AndInsertTaking1And1AndCreatesStrBuilderTakingNoArguments() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.insert(0, (float) 0);
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReplaceFirstTaking1And1() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(".70BVt=V");
        StrMatcher arg0 = StrMatcher.tabMatcher();
        StrBuilder replaceFirst = strBuilder.replaceFirst(arg0, "|uJyFMSV`ruboz%");
        assertEquals(8, replaceFirst.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetNewLineTextReturningNull() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(" 6$BZ|+H^D(bV");
        strBuilder.getNewLineText();
        assertEquals(45, strBuilder.capacity());
        assertEquals(13, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTakingStringReturningNegative() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        int indexOf = strBuilder.indexOf((String) null);
        assertEquals((-1), indexOf);
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBuildReturningNonEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("'Rd~CHa$");
        String build = strBuilder.build();
        assertEquals("'Rd~CHa$", build);
        assertEquals(40, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendFixedWidthPadLeftTaking2IntsAnd1ReturningStrBuilderWhereSizeIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder appendFixedWidthPadLeft = strBuilder.appendFixedWidthPadLeft((-1993), (-1993), 'g');
        assertEquals(32, appendFixedWidthPadLeft.capacity());
        assertEquals(0, appendFixedWidthPadLeft.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTakingCharReturningPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("+Y9iQ16O1]w{");
        int indexOf = strBuilder.indexOf('9');
        assertEquals(12, strBuilder.size());
        assertEquals(2, indexOf);
        assertEquals(44, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReplaceAllTaking1And1ReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("java.vm.name");
        StrMatcher.StringMatcher arg0 = new StrMatcher.StringMatcher("M");
        StrBuilder replaceAll = strBuilder.replaceAll((StrMatcher) arg0, "java.vm.name");
        assertEquals(12, replaceAll.size());
        assertEquals(44, replaceAll.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendlnTaking2Arguments() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.appendln("xQuF-yHB**)qRQZuI,", (Object[]) null);
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testInsertTaking1And1AndInsertTaking1And1AndCreatesStrBuilderTakingInt() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(0);
        strBuilder.insert(0, 'z');
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetNewLineTextReturningNonEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(" 6$BZ|+H^D(bV");
        strBuilder.setNewLineText(" 6$BZ|+H^D(bV");
        strBuilder.getNewLineText();
        assertEquals(45, strBuilder.capacity());
        assertEquals(13, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToStringBufferReturningStringBufferWhereLengthIsZero() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(3574);
        StringBuffer stringBuffer = strBuilder.toStringBuffer();
        assertEquals(3574, strBuilder.capacity());
        assertEquals(0, stringBuffer.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendlnTakingObject() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.appendln((Object) null);
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendSeparatorTaking2CharsWithOtherCharAndOtherChar() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("2{rkXHU/AA79)");
        strBuilder.appendSeparator('', '');
        assertEquals(15, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTakingStrMatcherReturningPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(" 6$BZ|+H^D(bV");
        StrMatcher arg0 = StrMatcher.charSetMatcher(" 6$BZ|+H^D(bV");
        int lastIndexOf = strBuilder.lastIndexOf(arg0);
        assertEquals(13, strBuilder.length());
        assertEquals(45, strBuilder.capacity());
        assertEquals(12, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteAllTakingCharWithDigit() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.appendln(13);
        strBuilder.deleteAll('3');
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCapacity() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        int capacity = strBuilder.capacity();
        assertEquals(32, capacity);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTakingStringReturningPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(" 6$BZ|+H^D(bV");
        int lastIndexOf = strBuilder.lastIndexOf("");
        assertEquals(12, lastIndexOf);
        assertEquals(45, strBuilder.capacity());
        assertEquals(13, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendlnTakingBoolean() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.appendln(true);
        assertEquals(5, strBuilder.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteFirstTakingStrMatcher() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StrBuilder deleteFirst = strBuilder.deleteFirst((StrMatcher) null);
        assertEquals(32, deleteFirst.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendFixedWidthPadLeftTaking11And1ReturningStrBuilderWhereSizeIsPositive() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.appendFixedWidthPadLeft((Object) null, 42, 'o');
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendlnTakingStringBuilder() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        StringBuilder arg0 = new StringBuilder();
        strBuilder.appendln(arg0);
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeleteFirstTakingCharWithDigit() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(" 6$BZ|+H^D(bV");
        strBuilder.deleteFirst('6');
        assertEquals(12, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTakingInt() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder("Afi|,");
        strBuilder.append((-2468));
        assertEquals(11, strBuilder.size());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesStrBuilderTakingIntAndCallsAppendlnTaking1And2Ints() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder(1);
        strBuilder.appendln("r-#oy.", 1, 1);
        assertFalse(strBuilder.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubstringTakingIntReturningEmptyString() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        String substring = strBuilder.substring(0);
        assertEquals(32, strBuilder.capacity());
        assertEquals("", substring);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testMarkSupported() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        StrBuilder.StrBuilderReader strBuilder_StrBuilderReader = arg0.new StrBuilderReader();
        boolean markSupported = strBuilder_StrBuilderReader.markSupported();
        assertEquals(32, arg0.capacity());
        assertTrue(markSupported);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testMark() throws Throwable  {
        StrBuilder arg0 = new StrBuilder("Windows 9");
        StrBuilder.StrBuilderReader strBuilder_StrBuilderReader = arg0.new StrBuilderReader();
        strBuilder_StrBuilderReader.mark(97);
        assertEquals(41, arg0.capacity());
        assertEquals(9, arg0.length());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReset() throws Throwable  {
        StrBuilder arg0 = new StrBuilder();
        StrBuilder.StrBuilderReader strBuilder_StrBuilderReader = arg0.new StrBuilderReader();
        strBuilder_StrBuilderReader.reset();
        assertFalse(strBuilder_StrBuilderReader.ready());
        assertEquals(32, arg0.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloseAndCreatesStrBuilderTakingStringAndCreatesStrBuilderReaderTakingStrBuilder() throws Throwable  {
        StrBuilder arg0 = new StrBuilder((String) null);
        StrBuilder.StrBuilderReader strBuilder_StrBuilderReader = arg0.new StrBuilderReader();
        strBuilder_StrBuilderReader.close();
        assertEquals(32, arg0.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAsReader() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.asReader();
        assertEquals(32, strBuilder.capacity());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAsTokenizer() throws Throwable  {
        StrBuilder strBuilder = new StrBuilder();
        strBuilder.asTokenizer();
        assertEquals(32, strBuilder.capacity());
    }
  }
  