*
     * @param remoteKey remote memory key for RDMA access (token)
     * @param address remote memory address (offset)
     * @param length length of the memory region
     */
    public RdmaChannelInfo(int remoteKey, long address, int length) {
        // Create SMB2_RDMA_TRANSFORM structure
        this.transform = new Smb2RdmaTransform(address, remoteKey, length);
    }

    /**
     * Create from SMB2 RDMA Transform
     *

    }
    final class Splitr extends MapWithIndexSpliterator<Spliterator.OfLong, R, Splitr>
        implements LongConsumer {
      long holder;

      Splitr(Spliterator.OfLong splitr, long index) {
        super(splitr, index);
      }

      @Override
      public void accept(long t) {
        this.holder = t;
      }

      @Override
      public boolean tryAdvance(Consumer<? super R> action) {

          i += 4;
          len += 4;
        } else {
          break;
        }
      }

      long buffer = 0;
      int shift = 0;
      for (; i < utf16Length; i++) {
        char c = input.charAt(i);
        if (c < 0x80) {
          buffer |= (long) c << shift;
          shift += 8;
          len++;
        } else if (c < 0x800) {
          buffer |= charToTwoUtf8Bytes(c) << shift;

     */
    @Override
    public void iterate(final String sessionId, final AccessResultCallback<AccessResultImpl<Long>> accessResultCallback) {
        final Map<String, AccessResultImpl<Long>> arMap = dataHelper.getAccessResultMap(sessionId);
        for (final Map.Entry<String, AccessResultImpl<Long>> entry : arMap.entrySet()) {
            accessResultCallback.iterate(entry.getValue());
        }
    }

    /**

        return this;
    }

    public void setCreatedTime_Equal(Long createdTime) {
        setCreatedTime_Term(createdTime, null);
    }

    public void setCreatedTime_Equal(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setCreatedTime_Term(createdTime, opLambda);
    }

    public void setCreatedTime_Term(Long createdTime) {
        setCreatedTime_Term(createdTime, null);
    }

    for (int value : TEST_INTS) {
      long expected = value & 0xffffffffL;
      assertWithMessage(UnsignedInts.toString(value))
          .that(UnsignedInteger.fromIntBits(value).longValue())
          .isEqualTo(expected);
    }
  }

  public void testValueOfLong() {
    long min = 0;
    long max = (1L << 32) - 1;
    for (long value : TEST_LONGS) {

        long expectedTimestamp = -1L; // Represents all bits set to 1 for an 8-byte long
        byte[] rawBytes = new byte[8];
        SMBUtil.writeInt8(expectedTimestamp, rawBytes, 0);
        AvTimestamp avTimestamp = new AvTimestamp(rawBytes);

        assertEquals(expectedTimestamp, avTimestamp.getTimestamp());
    }

    /**
     * Test round-trip conversion: long -> bytes -> long.
     */
    @Test

        // Negative values remain negative when stored in long fields
        // The calculations will result in negative values
        long expectedCapacity = (long) alloc * sectPerAlloc * bytesPerSect;
        assertEquals(expectedCapacity, smbInfoAllocation.getCapacity());

        long expectedFree = (long) free * sectPerAlloc * bytesPerSect;

        // Test with MAX_VALUE
        long maxMid = Long.MAX_VALUE;
        doNothing().when(messageBlock).setMid(maxMid);
        when(messageBlock.getMid()).thenReturn(maxMid);

        messageBlock.setMid(maxMid);
        assertEquals(maxMid, messageBlock.getMid());

        // Test with MIN_VALUE
        long minMid = Long.MIN_VALUE;
        doNothing().when(messageBlock).setMid(minMid);

   *
   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either
   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
   */
  // We use this method only for cases in which we need to decompose to primitives.