if (root instanceof InterruptedException) {
            ioe = new InterruptedIOException(root.getMessage());
            ioe.initCause(root);
        }
        return ioe;
    }

    /**
     * Closes this input stream and releases any system resources associated with the stream.
     *
     * @throws IOException
     *             if a network error occurs
     */

    @Override

    }

    @Test
    @DisplayName("Should handle multiple closes gracefully")
    void testMultipleCloses() {
        // Given
        Smb2EncryptionContext context = new Smb2EncryptionContext(EncryptionNegotiateContext.CIPHER_AES128_CCM, DialectVersion.SMB300,
                testEncryptionKey, testDecryptionKey);

        // When/Then - Multiple closes should be safe
        assertDoesNotThrow(() -> {

   * This is typically invoked immediately before bytes are returned to the application. If the
   * response body is empty this is invoked immediately before returning that to the application.
   *
   * If the application closes the response body before attempting a read, this is invoked at the
   * time it is closed.
   *
   * The connection is implicit, and will generally relate to the last [connectionAcquired] event.
   *

  override fun clone(): Call = RealCall(client, originalRequest, forWebSocket)

  override fun request(): Request = originalRequest

  /**
   * Immediately closes the socket connection if it's currently held. Use this to interrupt an
   * in-flight request from any thread. It's the caller's responsibility to close the request body

   * - Both request discover no existing connection. They both make a connection.
   * - The first request "wins the race".
   * - The second request discovers it "lost the race" and closes the connection it just opened.
   * - The second request uses the coalesced connection from request1.
   * - The coalesced connection is violently closed after servicing the first request.

        // Cannot check password after closing as it now throws IllegalStateException
        // This is actually good security practice - closed authenticators cannot be accessed

        // Verify multiple closes don't cause issues
        auth.close(); // Should be safe to call again
        assertTrue(auth.isClosed());
    }

    /**
     * Test AutoCloseable implementation
     */
    @Test

                holder.add(smbAuthentication);
            }
        }
        smbAuthenticationHolder = holder;
    }

    /**
     * Closes the SMB client, releasing resources.
     */
    @Override
    public void close() {
        smbAuthenticationHolder = null;
    }

    /*
     * (non-Javadoc)
     *

// contain only map or slice types, and clear performs the operation
// implied by the type argument. If t is nil, clear is a no-op.
func clear[T ~[]Type | ~map[Type]Type1](t T)

// The close built-in function closes a channel, which must be either
// bidirectional or send-only. It should be executed only by the sender,
// never the receiver, and has the effect of shutting down the channel after

                retryCount++;
            }
        }
    }

    /**
     * Destroys the client and closes connections.
     */
    @PreDestroy
    public void destroy() {
        if (client != null) {
            try {
                client.close();
            } catch (final OpenSearchException e) {

		eps := make([]Endpoint, s.setDriveCount)
		copy(eps, s.endpoints.Endpoints[setIndex*s.setDriveCount:setIndex*s.setDriveCount+s.setDriveCount])
		return eps
	}
}

// GetDisks returns a closure for a given set, which provides list of disks per set.
func (s *erasureSets) GetDisks(setIndex int) func() []StorageAPI {
	return func() []StorageAPI {
		s.erasureDisksMu.RLock()
		defer s.erasureDisksMu.RUnlock()