// 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

            return Integer.parseInt(versionStr);
        } catch (Exception e) {
            return 0;
        }
    }

    /**
     * Close the key manager and securely wipe all keys
     */
    @Override
    public void close() {
        if (closed) {
            return;
        }

        log.info("Closing SecureKeyManager and wiping all keys");

        try {

     * Checks if storage is properly configured and accessible.
     *
     * @return true if storage is available
     */
    boolean isAvailable();

    /**
     * Closes the client and releases resources.
     */
    @Override
    void close();

import java.util.stream.Stream;

/**
 * A destination to which characters can be written, such as a text file. Unlike a {@link Writer}, a
 * {@code CharSink} is not an open, stateful stream that can be written to and closed. Instead, it
 * is an immutable <i>supplier</i> of {@code Writer} instances.
 *
 * <p>{@code CharSink} provides two kinds of methods:
 *
 * <ul>

      object : EventListener() {
        var socket: SSLSocket? = null
        var closed = false

        override fun connectionAcquired(
          call: Call,
          connection: Connection,
        ) {
          socket = connection.socket() as SSLSocket
        }

        override fun requestHeadersStart(call: Call) {
          if (closed) {
            throw IOException("fake socket failure")
          }
        }

        return FileUtil.getCanonicalPath(jarFile);
    }

    /**
     * Closes the JAR file.
     * <p>
     * If {@link JarFile#close()} throws an exception, an error message is logged. The exception is not re-thrown.
     * </p>
     *
     * @param jarFile the JAR file (must not be {@literal null})
     */
    public static void close(final JarFile jarFile) {
        assertArgumentNotNull("jarFile", jarFile);

    }
  }

  @Test fun closeReservedSetThrows() {
    data.write("880203ec".decodeHex()) // Close with code 1004
    data.write("880203ed".decodeHex()) // Close with code 1005
    data.write("880203ee".decodeHex()) // Close with code 1006
    for (i in 1015..2999) {
      data.write(("8802" + format("%04X", i)).decodeHex()) // Close with code 'i'
    }
    var count = 0
    while (!data.exhausted()) {

 *
 * ```java
 * client.connectionPool().evictAll();
 * ```
 *
 * If your client has a cache, call [close()][Cache.close]. Note that it is an error to create calls
 * against a cache that is closed, and doing so will cause the call to crash.
 *
 * ```java
 * client.cache().close();
 * ```
 *
 * OkHttp also uses daemon threads for HTTP/2 connections. These will exit automatically if they
 * remain idle.

      .assertFailure("canceled", "Canceled", "Socket closed", "Socket is closed")
  }

  @Test
  fun cancelAll() {
    val call = client.newCall(Request(server.url("/")))
    call.enqueue(callback)
    client.dispatcher.cancelAll()
    callback
      .await(server.url("/"))
      .assertFailure("canceled", "Canceled", "Socket closed", "Socket is closed")
  }

  @Test

  fun `unterminated edit is reverted on cache close`() {
    val editor = cache.edit("k1")!!
    editor.setString(0, "AB")
    editor.setString(1, "C")
    cache.close()
    val expected = if (windows) arrayOf("DIRTY k1") else arrayOf("DIRTY k1", "REMOVE k1")
    assertJournalEquals(*expected)
    editor.commit()
    assertJournalEquals(*expected) // 'REMOVE k1' not written because journal is closed.
  }

  @Test