*/
internal fun BufferedSource.isProbablyUtf8(codePointLimit: Long = Long.MAX_VALUE): Boolean {
  try {
    val peek = peek()
    for (i in 0 until codePointLimit) {
      if (peek.exhausted()) {
        break
      }
      val codePoint = peek.readUtf8CodePoint()
      if (Character.isISOControl(codePoint) && !Character.isWhitespace(codePoint)) {
        return false
      }
    }
    return true

      UnmodifiableIterator<T> iterator) {
    return checkNotNull(iterator);
  }

  /**
   * Returns the number of elements remaining in {@code iterator}. The iterator will be left
   * exhausted: its {@code hasNext()} method will return {@code false}.
   */
  public static int size(Iterator<?> iterator) {
    long count = 0L;
    while (iterator.hasNext()) {
      iterator.next();
      count++;
    }

   * connection to an address fails, OkHttp will retry the connection with the next address until
   * either a connection is made, the set of IP addresses is exhausted, or a limit is exceeded.
   */
  @Throws(UnknownHostException::class)
  fun lookup(hostname: String): List<InetAddress>

  companion object {
    /**

  ) : SocketEffect

  /**
   * On HTTP/2, send a [GOAWAY frame](https://tools.ietf.org/html/rfc7540#section-6.8) immediately
   * after the response and will close the connection when the client's socket is exhausted.
   *
   * On HTTP/1 this closes the socket.
   */
  public object ShutdownConnection : SocketEffect

  /**
   * On HTTP/2 this will send the error code on the stream.
   *

        // After last element, hasNext should be false and calling close() should send Smb2CloseRequest once
        assertFalse(it.hasNext(), "Iterator should be exhausted");

        // Close explicitly to exercise doCloseInternal
        it.close();

        // Verify interactions: one create, two additional directory queries (for fetchMore), one close

        // Constructor gets entry1, first next() returns it and gets entry2,
        // second next() returns entry2 and gets entry3,
        // third next() returns entry3 and exhausts
        when(delegate.hasNext()).thenReturn(true, true, true, false);
        when(delegate.next()).thenReturn(entry1, entry2, entry3);

        TestIterator iterator = new TestIterator(null);

  fun sourceEmpty() {
    val mediaType = if (null == null) null else "any/thing; charset=${null}".toMediaType()
    val body = "".decodeHex().toResponseBody(mediaType)
    val source = body.source()
    assertThat(source.exhausted()).isTrue()
    assertThat(source.readUtf8()).isEqualTo("")
  }

  @Test
  fun sourceClosesUnderlyingSource() {
    var closed = false

    val body: ResponseBody =
      object : ResponseBody() {

    /**
     * Static factory for connection pool exhaustion
     */
    public static SmbResourceException connectionPoolExhausted(int errorCode, int poolSize) {
        return new SmbResourceException("Connection pool exhausted", errorCode, ResourceType.CONNECTION, 0, poolSize);
    }

    /**
     * Static factory for quota exceeded
     */
    public static SmbResourceException quotaExceeded(int errorCode, long used, long quota) {

 *
 * <p>The value you pass to the parameter {@code steps} should be greater than the length of your
 * iterator, so that this class can check that your iterator behaves correctly when it is exhausted.
 *
 * <p>For example, to test {@link java.util.Collections#unmodifiableList(java.util.List)
 * Collections.unmodifiableList}'s iterator:
 *
 * {@snippet :
 * List<String> expectedElements =

        assertTrue(it.hasNext());
        assertEquals("b", it.next().getName(), "Next element should skip '.' and '..'");
        assertFalse(it.hasNext(), "Iterator exhausted after valid entries");
        verify(tree, times(1)).release(); // closed after exhaustion
    }

    @ParameterizedTest
    @ValueSource(strings = { "", "file.txt", "subdir" })