CloseableUtil.close(out);
    }

    private static class NotifyOutputStream extends OutputStream {
        private String notify_;

        @Override
        public void write(final int arg0) throws IOException {
        }

        @Override
        public void close() throws IOException {
            super.close();
            notify_ = "closed";
        }

    while (true) {
      if (closed) throw IOException("closed")

      if (frameLength > 0L) {
        source.readFully(messageFrameBuffer, frameLength)

        if (!isClient) {
          messageFrameBuffer.readAndWriteUnsafe(maskCursor!!)
          maskCursor.seek(messageFrameBuffer.size - frameLength)
          toggleMask(maskCursor, maskKey!!)
          maskCursor.close()
        }
      }

    if (connectionUser.candidateConnection() != null) {
      check(toClose == null)
      return ReusePlan(candidate)
    }

    // The call's connection was released.
    toClose?.closeQuietly()
    connectionUser.connectionReleased(candidate)
    connectionUser.connectionConnectionReleased(candidate)
    if (toClose != null) {
      connectionUser.connectionConnectionClosed(candidate)

permissions:
  contents: read

jobs:
  stale:
    permissions:
      issues: write  # for actions/stale to close stale issues
      pull-requests: write  # for actions/stale to close stale PRs
    runs-on: ubuntu-latest
    env:
      ACTIONS_STEP_DEBUG: true
    steps:
    - name: Close Stale Issues
      uses: actions/stale@v8
      with:
        repo-token: ${{ secrets.GITHUB_TOKEN }}

        throw complete(e)!!
      }
    }

    @Throws(IOException::class)
    override fun close() {
      if (closed) return
      closed = true
      if (contentLength != -1L && bytesReceived != contentLength) {
        throw ProtocolException("unexpected end of stream")
      }
      try {
        super.close()
        complete(null)
      } catch (e: IOException) {
        throw complete(e)!!
      }

        }
    }

    @Test
    @DisplayName("EmptyIterator should handle close operations multiple times")
    void testMultipleCloseOperations() {
        // When & Then
        assertDoesNotThrow(() -> {
            try {
                emptyIterator.close();
                emptyIterator.close();
                emptyIterator.close();
            } catch (CIFSException e) {
                throw new RuntimeException(e);

          assertThat(dispatcherE.closed).isTrue()
          assertThat(dispatcherF.closed).isFalse() // Never started.
        }
      }
  }

  class ClosableDispatcher : Dispatcher() {
    var closed = false

    override fun dispatch(request: RecordedRequest) = MockResponse()

    override fun close() {
      closed = true
    }
  }

	h          hash.Hash
	shardSize  int64
	hashBytes  []byte
}

func (b *streamingBitrotReader) Close() error {
	if b.rc == nil {
		return nil
	}
	if closer, ok := b.rc.(io.Closer); ok {
		// drain the body for connection reuse at network layer.
		xhttp.DrainBody(io.NopCloser(b.rc))
		return closer.Close()
	}
	return nil
}

func (b *streamingBitrotReader) ReadAt(buf []byte, offset int64) (int, error) {

        // Mock isOpen to return false after close
        doAnswer(new Answer<Void>() {
            @Override
            public Void answer(InvocationOnMock invocation) throws Throwable {
                when(smbFile.isOpen()).thenReturn(false);
                return null;
            }
        }).when(smbFile).close(anyLong());

        smbRandomAccessFile.close();

     */
    @Override
    void close() throws CIFSException;

    /**
     * Releases this file handle without closing it
     *
     * @throws CIFSException if an error occurs while releasing the handle
     */
    void release() throws CIFSException;

    /**
     * Returns the initial size of the file when it was opened
     *
     * @return the file size when it was opened
     */