Closeables.closeQuietly(in);
    assertTrue(in.closed());
  }

  public void testCloseQuietly_readerWithEatenException() throws IOException {
    TestReader in = new TestReader(TestOption.CLOSE_THROWS);
    Closeables.closeQuietly(in);
    assertTrue(in.closed());
  }

  public void testCloseNull() throws IOException {
    Closeables.close(null, true);
    Closeables.close(null, false);
  }

                testEncryptionKey, testDecryptionKey);

        // When/Then - Multiple closes should be safe
        assertDoesNotThrow(() -> {
            context.close();
            context.close();
            context.close();
        });

        assertTrue(context.isClosed());
    }

    @Test
    @DisplayName("Should handle concurrent operations with SecureKeyManager")

    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()
        }
      }

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

    }

    @Test
    @DisplayName("ensureOpen throws after close() is called")
    void testEnsureOpenAfterClose() throws CIFSException {
        target.close();
        CIFSException ex = assertThrows(SmbException.class, () -> target.ensureOpen());
        assertTrue(ex.getMessage().contains("Pipe handle already closed"));
    }

    @Test

   * This method returns true if the message was enqueued. Messages that would overflow the outgoing
   * message buffer will be rejected and trigger a [graceful shutdown][close] of this web socket.
   * This method returns false in that case, and in any other case where this web socket is closing,
   * closed, or canceled.
   *
   * This method returns immediately.
   */
  fun send(text: String): Boolean

  /**

# Number of days of inactivity before an Issue or Pull Request becomes stale
daysUntilStale: 30

# Number of days of inactivity before an Issue or Pull Request with the stale label is closed.
# Set to false to disable. If disabled, issues still need to be closed manually, but will remain marked as stale.
daysUntilClose: 15

# Only issues or pull requests with all of these labels are check if stale. Defaults to `[]` (disabled)
onlyLabels: []

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

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

    /**
     * Wraps exception handling for {@link Properties#load(InputStream)}.
     * <p>
     * The input stream is not closed.
     * </p>
     *
     * @param props the property set (must not be {@literal null})
     * @param in the input stream (must not be {@literal null})
     */

  }

  @Throws(IOException::class)
  fun flush() {
    withLock {
      if (closed) throw IOException("closed")
      sink.flush()
    }
  }

  @Throws(IOException::class)
  fun rstStream(
    streamId: Int,
    errorCode: ErrorCode,
  ) {
    withLock {
      if (closed) throw IOException("closed")
      require(errorCode.httpCode != -1)

      frameHeader(
        streamId = streamId,