*/
    protected String createTestString(int length) {
        StringBuilder sb = new StringBuilder(length);
        for (int i = 0; i < length; i++) {
            sb.append((char) ('A' + (i % 26)));
        }
        return sb.toString();
    }

create table DUMMY_MEMBER(
    MEMBER_ID INTEGER IDENTITY NOT NULL PRIMARY KEY,
    MEMBER_NAME VARCHAR(200) NOT NULL,
    MEMBER_ACCOUNT VARCHAR(50) NOT NULL,
    MEMBER_STATUS_CODE CHAR(3) NOT NULL,
    FORMALIZED_DATETIME DATETIME,
    BIRTHDATE DATE,
    REGISTER_DATETIME DATETIME NOT NULL,
    REGISTER_USER VARCHAR(200) NOT NULL,
    UPDATE_DATETIME DATETIME NOT NULL,
    UPDATE_USER VARCHAR(200) NOT NULL,
    VERSION_NO BIGINT NOT NULL

     *
     * <p>It is strongly encouraged to use {@link #add(String, char)} instead and give value a
     * readable name.
     *
     * @since 18.0 (since 11.0 as {@code Objects.ToStringHelper.addValue()}).
     */
    @CanIgnoreReturnValue
    public ToStringHelper addValue(char value) {
      return addUnconditionalHolder(String.valueOf(value));
    }

    /**

        assertTrue(raf.readBoolean());
        assertEquals((byte) 0xFF, raf.readByte());
        assertEquals(0xFF, raf.readUnsignedByte());
    }

    @Test
    @DisplayName("readShort/UnsignedShort/Char: big-endian decoding")
    void read_twoByteVariants() throws Exception {
        SmbRandomAccessFile raf = spy(newInstance("r", false, false, false));
        doAnswer(inv -> {
            byte[] b = inv.getArgument(0);

                }
            } else if (Character.isDigit(line.charAt(0))) {
                final char[] data = line.toCharArray();
                int ip, i, j;
                Name name;
                NbtAddress addr;
                char c = '.';

                ip = i = 0;
                for (; i < data.length && c == '.'; i++) {
                    int b = 0x00;

    BufferedReader reader = source.openBufferedStream();
    assertTrue(source.wasStreamOpened());
    assertFalse(source.wasStreamClosed());

    StringWriter writer = new StringWriter();
    char[] buf = new char[64];
    int read;
    while ((read = reader.read(buf)) != -1) {
      writer.write(buf, 0, read);
    }
    reader.close();
    writer.close();

    assertTrue(source.wasStreamClosed());

    LineBuffer lineBuf =
        new LineBuffer() {
          @Override
          protected void handleLine(String line, String end) {
            lines.add(line + end);
          }
        };
    char[] chars = input.toCharArray();
    int off = 0;
    while (off < chars.length) {
      int len = min(chars.length, off + chunk) - off;
      lineBuf.add(chars, off, len);
      off += len;
    }

    LineBuffer lineBuf =
        new LineBuffer() {
          @Override
          protected void handleLine(String line, String end) {
            lines.add(line + end);
          }
        };
    char[] chars = input.toCharArray();
    int off = 0;
    while (off < chars.length) {
      int len = min(chars.length, off + chunk) - off;
      lineBuf.add(chars, off, len);
      off += len;
    }

import com.google.caliper.Benchmark;
import com.google.caliper.Param;
import com.google.common.collect.Iterables;
import org.jspecify.annotations.NullUnmarked;

/**
 * Microbenchmark for {@link Splitter#on} with char vs String with length == 1.
 *
 * @author Paul Lindner
 */
@NullUnmarked
public class SplitterBenchmark {
  // overall size of string
  @Param({"1", "10", "100", "1000"})
  int length;

   * Returns a reader wrapping the given reader that only reads half of the maximum number of
   * characters that it could read in read(char[], int, int).
   */
  private static Reader newNonBufferFillingReader(Reader reader) {
    return new FilterReader(reader) {
      @Override
      public int read(char[] cbuf, int off, int len) throws IOException {