void ensureBucketExists();

    /**
     * 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();

        assertArgumentNotNull("zis", zis);

        try {
            zis.reset();
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Closes the {@link ZipInputStream}.
     * <p>
     * If {@link ZipInputStream#closeEntry()} throws an exception, an error message is logged.
     * The exception is not rethrown.
     * </p>
     *
     * @param zis

  private final Iterator<? extends CharSource> it;
  private @Nullable Reader current;

  MultiReader(Iterator<? extends CharSource> readers) throws IOException {
    this.it = readers;
    advance();
  }

  /** Closes the current reader and opens the next one, if any. */
  private void advance() throws IOException {
    close();
    if (it.hasNext()) {
      current = it.next().openStream();
    }
  }

  @Override

import okio.ForwardingSink
import okio.ForwardingSource
import okio.asOkioSocket
import okio.buffer

/**
 * Adapts a [java.net.Socket] to MockWebServer's needs.
 *
 * Note that [asOkioSocket] returns a socket that closes the underlying [java.net.Socket] when both
 * of its component streams are closed. This class takes advantage of that.
 */
internal class MockWebServerSocket(
  val javaNetSocket: Socket,
) : Closeable,
  BufferedSocket {

     * @return message length
     * @throws SMBProtocolDecodingException if decoding fails
     */
    int decode(byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException;

    /**
     * Encodes this message into a byte array.
     *
     * @param dst the destination byte array
     * @param dstIndex the starting index in the destination array
     * @return message length
     */

	return fmt.Errorf("%w (offline-disks=%d/%d)", writeErr, countErrs(p.errs, errDiskNotFound), len(p.writers))
}

// Encode reads from the reader, erasure-encodes the data and writes to the writers.
func (e *Erasure) Encode(ctx context.Context, src io.Reader, writers []io.Writer, buf []byte, quorum int) (total int64, err error) {
	writer := &multiWriter{
		writers:     writers,

    private static final Logger logger = Logger.getLogger(ResultSetUtil.class);

    /**
     * Do not instantiate.
     */
    protected ResultSetUtil() {
    }

    /**
     * Closes the result set.
     * <p>
     * If {@link ResultSet#close()} throws an exception, an error message is logged. The exception is not rethrown.
     * </p>
     *
     * @param resultSet
     *            The result set

        handle.sendrecv(rpc);
        if (rpc.retval != 0) {
            throw new SmbException(rpc.retval, false);
        }
    }

    /**
     * Closes this SAM domain handle.
     *
     * @throws IOException if an I/O error occurs during handle closure
     */
    public void close() throws IOException {

                throw de;
            }

            final MsrpcSamrConnect2 rpc2 = new MsrpcSamrConnect2(server, access, this);
            handle.sendrecv(rpc2);
        }
    }

    /**
     * Closes this SAM policy handle.
     *
     * @throws IOException if an I/O error occurs during handle closure
     */
    public void close() throws IOException {

    checkNotNull(input);

    try (OutputStream out = openStream()) {
      return ByteStreams.copy(input, out);
    }
  }

  /**
   * A char sink that encodes written characters with a charset and writes resulting bytes to this
   * byte sink.
   */
  private final class AsCharSink extends CharSink {

    private final Charset charset;