* @param delegate
     *            delegate to pass all non-overridden method calls to
     *
     */
    public DelegatingConfiguration(final Configuration delegate) {
        this.delegate = delegate;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Configuration#getRandom()
     */
    @Override
    public SecureRandom getRandom() {
        return this.delegate.getRandom();
    }

    /**

    private final ProgressListener progressListener;
    private final RequestBody delegate;

    public ProgressRequestBody(RequestBody delegate, ProgressListener progressListener) {
      this.delegate = delegate;
      this.progressListener = progressListener;
    }

    @Override
    public MediaType contentType() {
      return delegate.contentType();
    }

    @Override

     * @param context the CIFS context for configuration
     */
    public RdmaTransport(SmbTransportInternal delegate, CIFSContext context) {
        this.delegate = delegate;
        this.rdmaProvider = RdmaProviderFactory.getProvider(context.getConfig());
        this.bufferManager = new RdmaBufferManager(rdmaProvider);
        this.statistics = new RdmaStatistics();

                // release
                old.release(true);
            }
            if (this.delegate != null && this.delegateAcquired) {
                log.debug("Releasing delegate");
                this.delegateAcquired = false;
                this.delegate.release();
            }
        }
    }

    /**
     * @return tree connection with increased usage count
     */

    }
  }

  private class ProgressRequestBody(
    private val delegate: RequestBody,
    private val progressListener: ProgressListener,
  ) : RequestBody() {
    override fun contentType() = delegate.contentType()

    @Throws(IOException::class)
    override fun contentLength(): Long = delegate.contentLength()

    @Throws(IOException::class)
    override fun writeTo(sink: BufferedSink) {

          private final RequestBody delegate;

          public ProgressRequestBody(RequestBody delegate, ProgressListener progressListener) {
            this.delegate = delegate;
            this.progressListener = progressListener;
          }

          @Override public MediaType contentType() {
            return delegate.contentType();
          }

  }

  public void testPadEnd_null() {
    assertThrows(NullPointerException.class, () -> Strings.padEnd(null, 5, '0'));
  }

  @SuppressWarnings("InlineMeInliner") // test of method that doesn't just delegate
  public void testRepeat() {
    String input = "20";
    assertEquals("", Strings.repeat(input, 0));
    assertEquals("20", Strings.repeat(input, 1));
    assertEquals("2020", Strings.repeat(input, 2));

            assertTrue(transport.isDisconnected(), "Transport should be disconnected initially");

            System.out.println("RDMA transport created successfully with mock delegate");
        }
    }

    @Test
    public void testRdmaStatisticsTracking() throws Exception {
        RdmaStatistics stats = new RdmaStatistics();

        // Simulate various RDMA operations

    /**
     * Impersonation level - server can impersonate the client's security context on the local system
     */
    public static final int SMB2_IMPERSONATION_LEVEL_IMPERSONATION = 0x2;

    /**
     * Delegate impersonation level - server can impersonate the client's security context on remote systems
     */
    public static final int SMB2_IMPERSONATION_LEVEL_DELEGATE = 0x3;

    /**
     * Enable other opens for read access

  val originalRequest: Request,
  val forWebSocket: Boolean,
) : Call,
  Cloneable,
  Lockable {
  private val connectionPool: RealConnectionPool = client.connectionPool.delegate

  internal val eventListener: EventListener = client.eventListenerFactory.create(this)

  private val timeout =
    object : AsyncTimeout() {
      override fun timedOut() {
        ******@****.***()