* </p>
     *
     * @param closeable the closeable object
     * @see Closeable#close()
     */
    public static void close(final Closeable closeable) {
        if (closeable == null) {
            return;
        }
        try {
            closeable.close();
        } catch (final IOException e) {

            }
        }, "Multiple close operations should not cause issues");

        // Verify iterator still works after multiple closes
        assertFalse(emptyIterator.hasNext(), "Iterator should still work after multiple closes");
        assertNull(emptyIterator.next(), "Iterator should still return null after multiple closes");
    }

    @Test
    @DisplayName("EmptyIterator should handle remove operations multiple times")

        // Verify interactions
        verify(tree, times(1)).send(isA(Trans2FindFirst2.class), any(Trans2FindFirst2Response.class));
        // Verify that Trans2FindNext2 was sent twice for fetching more entries
        verify(tree, times(2)).send(isA(Trans2FindNext2.class), any(Trans2FindFirst2Response.class));

        // Close should have sent FindClose2 exactly once

      private var closed = false

      override fun close() {
        if (closed) return
        try {
          super.close()
        } finally {
          closedLatch.countDown()
        }
      }
    }.buffer()

  override val sink: BufferedSink =
    object : ForwardingSink(delegate.sink) {
      private var closed = false

      override fun close() {

        assertSame(info, result);
        verify(tree, atLeastOnce()).send(any(CommonServerMessageBlockRequest.class), any(), any(), any());
    }

    // close() should close underlying handle with 0L when valid
    @Test
    @DisplayName("close() closes underlying handle when valid")
    void close_validHandle_invokesClose() throws Exception {
        when(handle.isValid()).thenReturn(true);

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

    /**
     * Closes the LSA policy handle.
     *
     * @throws IOException if an I/O error occurs
     */
    public void close() throws IOException {
        final MsrpcLsarClose rpc = new MsrpcLsarClose(this);
        handle.sendrecv(rpc);
        if (rpc.retval != 0) {

        assertEquals("one", it.next().getName()); // consume initial
        // Next call should handle CIFSException and close iterator
        assertFalse(it.hasNext()); // After error, hasNext should return false

        // Assert
        verify(tree, times(1)).release();
    }

    @Test
    @DisplayName("close() closes when there is a next element and releases handle")
    void explicitClose() throws Exception {
        // Arrange

  when {
    this.isNullOrEmpty() -> emptyList()
    this.size == 1 -> Collections.singletonList(this[0])
    else -> this.clone().asList().unmodifiable()
  }

/** Closes this, ignoring any checked exceptions. */
internal fun Socket.closeQuietly() {
  try {
    close()
  } catch (e: AssertionError) {
    throw e
  } catch (rethrown: RuntimeException) {
    if (rethrown.message == "bio == null") {

     */
    boolean isValid();

    /**
     * Closes this file handle and optionally sets the last write time
     *
     * @param lastWriteTime the last write time to set, or 0 to leave unchanged
     * @throws CIFSException if an error occurs while closing the file
     */
    void close(long lastWriteTime) throws CIFSException;

    /**
     * {@inheritDoc}
     *

    return 0;
  }

  @Override
  public boolean ready() throws IOException {
    return (current != null) && current.ready();
  }

  @Override
  public void close() throws IOException {
    if (current != null) {
      try {
        current.close();
      } finally {
        current = null;
      }
    }
  }