val part = parts.nextPart()!!
    assertThat(part.headers).isEqualTo(headersOf())
    assertThat(part.body.readUtf8()).isEqualTo("abcd")

    assertThat(parts.nextPart()).isNull()
  }

  @Test fun `skip whitespace after boundary`() {
    val multipart =
      """
      |--simple boundary
      |
      |abcd
      |--simple boundary--
      """.trimMargin()

 * simplifies use of single-valued fields whose values routinely contain commas, such as cookies or
 * dates.
 *
 * This class trims whitespace from values. It never returns values with leading or trailing
 * whitespace.
 *
 * Instances of this class are immutable. Use [Builder] to create instances.
 */
@Suppress("NAME_SHADOWING")
class Headers internal constructor(

  val result = copyOf(size + 1)
  result[result.lastIndex] = value
  return result as Array<String>
}

/** Increments [startIndex] until this string is not ASCII whitespace. Stops at [endIndex]. */
internal fun String.indexOfFirstNonAsciiWhitespace(
  startIndex: Int = 0,
  endIndex: Int = length,
): Int {
  for (i in startIndex until endIndex) {
    when (this[i]) {

import static com.google.common.base.CharMatcher.is;
import static com.google.common.base.CharMatcher.isNot;
import static com.google.common.base.CharMatcher.noneOf;
import static com.google.common.base.CharMatcher.whitespace;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.collect.Sets;

        .inOrder();
  }

  public void testCharacterSplitWithMatcherDelimiter() {
    Iterable<String> testCharacteringMotto =
        Splitter.on(CharMatcher.whitespace()).split("Testing\nrocks\tDebugging sucks");
    assertThat(testCharacteringMotto)
        .containsExactly("Testing", "rocks", "Debugging", "sucks")
        .inOrder();
  }

        assertNull(exception.getCause());
    }

    public void test_constructor_withWhitespaceType() {
        // Test constructor with whitespace in type
        String type = "  Bearer Token  ";
        String message = "Whitespace in token type";
        InvalidAccessTokenException exception = new InvalidAccessTokenException(type, message);

        assertEquals("  Bearer Token  ", exception.getType());

        tags = PrunedTag.parse(null);
        assertEquals(0, tags.length);

        // Test whitespace only
        tags = PrunedTag.parse("   ");
        assertEquals(0, tags.length);

        // Test commas only
        tags = PrunedTag.parse(",,,");
        assertEquals(0, tags.length);

        // Test mixed whitespace and commas
        tags = PrunedTag.parse(" , , , ");
        assertEquals(0, tags.length);
    }

        RescorerBuilder<?> result = ltrQueryRescorer.evaluate(params);
        assertNull(result);
    }

    public void test_evaluate_withWhitespaceModelName() {
        // Test when model name contains only whitespace
        ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {
            @Override
            public String getLtrModelName() {
                return "   ";
            }

            @Override

     *            The character code.
     */
    protected static void wordChar(final byte[] ctype2, final int val) {
        ctype2[val] |= CT_ALPHA;
    }

    /**
     * Sets characters as whitespace.
     *
     * @param ctype2
     *            The array of character types.
     * @param low
     *            The minimum character code.
     * @param hi
     *            The maximum character code.

        item.setNewInput(newSpecialInput);
        assertEquals(newSpecialInput, item.toLineString());
    }

    public void test_whitespaceHandling() {
        // Test with various whitespace
        StopwordsItem item1 = new StopwordsItem(1, " ");
        assertEquals(" ", item1.getInput());
        assertEquals(" ", item1.toLineString());

        StopwordsItem item2 = new StopwordsItem(2, "\t\n\r");