private int fid, remaining, dataLength, dataOffset, off;
    private byte[] b;
    private long offset;

    private int pad;

    int writeMode;

    SmbComWriteAndX() {
        super(null);
        command = SMB_COM_WRITE_ANDX;
    }

    SmbComWriteAndX(final int fid, final long offset, final int remaining, final byte[] b, final int off, final int len,
            final ServerMessageBlock andx) {

internal class ThrottledSink(
  private val socket: MockWebServerSocket,
  private val delegate: Sink,
  private val bytesPerPeriod: Long,
  private val periodDelayNanos: Long,
) : Sink by delegate {
  private var bytesWrittenSinceLastDelay = 0L

  override fun write(
    source: Buffer,
    byteCount: Long,
  ) {
    var bytesLeft = byteCount

    while (bytesLeft > 0) {
      if (bytesWrittenSinceLastDelay == bytesPerPeriod) {

    protected long delayMillisAfterProcessing = 0L;

    /** Delay in milliseconds when no URL is in the queue */
    protected long delayMillisAtNoUrlInQueue = 500L;

    /** Delay in milliseconds before processing a URL */
    protected long delayMillisBeforeProcessing = 0L;

    /** Delay in milliseconds for waiting for new URLs */
    protected long delayMillisForWaitingNewUrl = 1000L;

    /**

  /* Helper function to make a Long value from an Integer. */
  private static final Function<Integer, Long> TO_LONG =
      new Function<Integer, Long>() {
        @Override
        public Long apply(Integer n) {
          return Long.valueOf(n);
        }
      };

  /* Helper function to make a BigInteger value from a Long. */
  private static final Function<Long, BigInteger> TO_BIGINTEGER =

    Helpers.testComparator(comparator, ordered);
  }

  public void testSort() {
    testSort(new long[] {}, new long[] {});
    testSort(new long[] {2}, new long[] {2});
    testSort(new long[] {2, 1, 0}, new long[] {0, 1, 2});
    testSort(new long[] {2, GREATEST, 1, LEAST}, new long[] {LEAST, 1, 2, GREATEST});
  }

        final long usage = this.usageCount.decrementAndGet();
        if (usage == 0) {
            closeInternal(0L, false);
        } else if (log.isTraceEnabled()) {
            log.trace(String.format("Release %s (%d)", this, usage));
        }
    }

    /**
     * {@inheritDoc}
     *
     * @see java.lang.Object#finalize()
     */
    @Override

    /** The creation time of the access result. */
    protected Long createTime;

    /** The execution time of the access. */
    protected Integer executionTime;

    /** The content length of the accessed resource. */
    protected Long contentLength;

    /** The last modified time of the accessed resource. */
    protected Long lastModified;

    /** The access result data. */

     * @param remoteKey remote memory key
     * @param length number of bytes to read
     * @throws IOException if read fails
     */
    public abstract void rdmaRead(RdmaMemoryRegion localRegion, long remoteAddress, int remoteKey, int length) throws IOException;

    /**
     * Perform RDMA write operation
     *
     * @param localRegion local memory region to write from

        resourceManager.markClosed(id1);

        Map<String, Object> stats = resourceManager.getStatistics();

        assertNotNull(stats);
        assertTrue((long) stats.get("totalAllocated") >= 2);
        assertTrue((long) stats.get("totalReleased") >= 1);
        assertNotNull(stats.get("activeResources"));
        assertNotNull(stats.get("closedResources"));
    }

    @Test

    /**
     * Gets the total capacity of the allocation.
     *
     * @return total capacity
     */
    long getCapacity();

    /**
     * Gets the free space available.
     *
     * @return free space
     */
    long getFree();