*
     * @param <T> return type
     * @param operation the operation to execute
     * @return operation result
     * @throws CIFSException if circuit is open or operation fails
     */
    public <T> T executeWithCircuitBreaker(Supplier<T> operation) throws CIFSException {
        // Backpressure control
        if (backpressureEnabled && requestSemaphore != null) {

        public void encode(NdrBuffer _dst) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_referent(this.entry_path, 1);

            if (this.entry_path != null) {
                _dst = _dst.deferred;
                _dst.enc_ndr_string(this.entry_path);

            }
        }

        @Override
        public void decode(NdrBuffer _src) throws NdrException {
            _src.align(4);

            close();
            throw new NbtException(NbtException.ERR_SSN_SRVC, errorCode);
        case -1:
            throw new NbtException(NbtException.ERR_SSN_SRVC, NbtException.CONNECTION_REFUSED);
        default:
            close();
            throw new NbtException(NbtException.ERR_SSN_SRVC, 0);
        }
    }

    @Override
    public void close() throws IOException {
        if (LogStream.level > 3) {

    @Override
    public void transferStarted(TransferEvent event) throws TransferCancelledException {
        if (ongoing.get(new TransferResourceIdentifier(event.getResource())) == Boolean.FALSE) {
            throw new TransferCancelledException();
        }
        put(event, false);
    }

    @Override
    public void transferProgressed(TransferEvent event) throws TransferCancelledException {

    @Override
    public void transferStarted(TransferEvent event) throws TransferCancelledException {
        if (ongoing.get(new TransferResourceIdentifier(event.getResource())) == Boolean.FALSE) {
            throw new TransferCancelledException();
        }
        put(event, false);
    }

    @Override
    public void transferProgressed(TransferEvent event) throws TransferCancelledException {

    }

    /**
     * Test constructor with null configuration
     */
    @Test
    @DisplayName("Test constructor throws NullPointerException with null configuration")
    public void testConstructorWithNullConfig() {
        // When & Then - should throw NullPointerException since ServerMessageBlock calls config.getPid()
        NullPointerException exception = assertThrows(NullPointerException.class, () -> {

    void closeDelegatesToUnderlyingStream(@Mock InputStream mockIn) throws IOException {
        SocketInputStream sis = new SocketInputStream(mockIn);
        sis.close();
        verify(mockIn).close();
    }

    @Test
    @DisplayName("Read array delegates to read with offset and length")
    void readArrayDelegatesToReadWithOffsetAndLength() throws IOException {
        // Create message with data

  }

  public void testBulkLoad_extra() throws ExecutionException {
    CacheLoader<Object, Object> loader =
        new CacheLoader<Object, Object>() {
          @Override
          public Object load(Object key) throws Exception {
            return new Object();
          }

          @Override
          public Map<Object, Object> loadAll(Iterable<?> keys) throws Exception {

    }
  }

  @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)

     *
     * @param url the SMB URL to read from
     * @throws SmbException if an SMB error occurs
     * @throws MalformedURLException if the URL is malformed
     * @throws UnknownHostException if the server cannot be resolved
     */
    public SmbFileInputStream(final String url) throws SmbException, MalformedURLException, UnknownHostException {
        this(new SmbFile(url));
    }

    /**