}

  /**
   * Tests that specifying any alphanumeric characters as 'safe' causes an {@link
   * IllegalArgumentException}.
   */
  public void testBadArguments_badchars() {
    String msg = "Alphanumeric characters are always 'safe' and should not be explicitly specified";
    IllegalArgumentException expected =

    if (size == i + 1L) return null // Dangling escape.
    result.write(this, i)
    // Consume '\'.
    readByte()
    result.write(this, 1L) // The escaped character.
  }
}

/**
 * Consumes and returns a non-empty token, terminating at special characters in
 * [TOKEN_DELIMITERS]. Returns null if the buffer is empty or prefixed with a delimiter.
 */
private fun Buffer.readToken(): String? {

/**
 * Converts Katakana characters to their corresponding Alphabet representations.
 *
 * <p>
 * This class implements the {@link ReadingConverter} interface and provides a method to convert a given
 * Katakana string into a list of possible Alphabet readings. It uses a predefined mapping of Katakana
 * characters to their Alphabet equivalents, handling both single and double Katakana character combinations.
 * </p>
 *
 * <p>

            assertThrows(IllegalArgumentException.class, () -> new UUID(invalidUuid),
                    "Should throw IllegalArgumentException for invalid character in UUID string");
        }

        @Test
        @DisplayName("Constructor with UUID string containing non-hex character should throw IllegalArgumentException")
        void testConstructorWithStringNonHexCharacter() {
            // Arrange

	file *os.File // If non-nil, file descriptor to close.
}

func NewTokenizer(name string, r io.Reader, file *os.File) *Tokenizer {
	var s scanner.Scanner
	s.Init(r)
	// Newline is like a semicolon; other space characters are fine.
	s.Whitespace = 1<<'\t' | 1<<'\r' | 1<<' '
	// Don't skip comments: we need to count newlines.
	s.Mode = scanner.ScanChars |
		scanner.ScanFloats |
		scanner.ScanIdents |
		scanner.ScanInts |

    val c = this[i]
    // The WHATWG Host parsing rules accepts some character codes which are invalid by
    // definition for OkHttp's host header checks (and the WHATWG Host syntax definition). Here
    // we rule out characters that would cause problems in host headers.
    if (c <= '\u001f' || c >= '\u007f') {
      return true
    }
    // Check for the characters mentioned in the WHATWG Host parsing spec:

    }

    /**
     * SAX event handler called to process character data between XML elements.
     * Accumulates text content in a buffer for later processing when the element ends.
     *
     * @param ch the characters from the XML document
     * @param start the start position in the character array
     * @param length the number of characters to use from the character array

        String msg = "\u00A1\u00A2"; // two Unicode characters
        byte[] encoded = encodeUnicode(msg);
        assertEquals(4, encoded.length, "Encoded Unicode string should be 4 bytes");

        // Verify little-endian encoding
        assertEquals((byte) 0xA1, encoded[0], "First byte of first character");
        assertEquals((byte) 0x00, encoded[1], "Second byte of first character");

    return total;
  }

  /**
   * Discards {@code n} characters of data from the reader. This method will block until the full
   * amount has been skipped. Does not close the reader.
   *
   * @param reader the reader to read from
   * @param n the number of characters to skip
   * @throws EOFException if this stream reaches the end before skipping all the characters
   * @throws IOException if an I/O error occurs
   */

 *       doing something and finally closing the writer that was opened.
 * </ul>
 *
 * <p>Any {@link ByteSink} may be viewed as a {@code CharSink} with a specific {@linkplain Charset
 * character encoding} using {@link ByteSink#asCharSink(Charset)}. Characters written to the
 * resulting {@code CharSink} will written to the {@code ByteSink} as encoded bytes.
 *
 * @since 14.0
 * @author Colin Decker
 */
@J2ktIncompatible
@GwtIncompatible