dstIndex++;

        return dstIndex - start;
    }

    @Override
    protected int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    protected int readBytesWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    public String toString() {

    void testWriteSetupWireFormat() {
        // Arrange
        transWaitNamedPipe = new TransWaitNamedPipe(mockConfig, testPipeName);
        byte[] dst = new byte[10];
        int dstIndex = 0;

        // Act
        int bytesWritten = transWaitNamedPipe.writeSetupWireFormat(dst, dstIndex);

        // Assert
        assertEquals(4, bytesWritten);
        assertEquals(SmbComTransaction.TRANS_WAIT_NAMED_PIPE, dst[0]);

     */
    public static final int SMB_DIRECT_RESPONSE_REQUESTED = 0x00000001;

    /**
     * Default maximum size for RDMA read/write operations (1MB)
     */
    public static final int DEFAULT_RDMA_READ_WRITE_SIZE = 1048576; // 1MB

    /**
     * Default maximum number of receive credits
     */
    public static final int DEFAULT_RECEIVE_CREDIT_MAX = 255;

    /**

    void testSetCloseFlags() throws Exception {
        int testFlags = 0x00000001; // SMB2_CLOSE_FLAG_POSTQUERY_ATTRIB
        request.setCloseFlags(testFlags);

        Field closeFlagsField = Smb2CloseRequest.class.getDeclaredField("closeFlags");
        closeFlagsField.setAccessible(true);
        int storedFlags = (int) closeFlagsField.get(request);
        assertEquals(testFlags, storedFlags);
    }

        long readFlags = 0;
        for (int i = 0; i < 8; i++) {
            readFlags |= ((long) (buffer[8 + i] & 0xFF)) << (i * 8);
        }
        assertEquals(flags, readFlags);
    }

    @Test
    @DisplayName("Test desired access setter")
    void testSetDesiredAccess() {
        request = new Smb2CreateRequest(mockConfig, "test.txt");

        int access = 0x12345678;

        FileEndOfFileInformation info = new FileEndOfFileInformation(endOfFile);

        // Create buffer with offset
        byte[] buffer = new byte[20];
        int offset = 5;
        int bytesWritten = info.encode(buffer, offset);

        assertEquals(8, bytesWritten);

        // Verify encoded value at offset
        long decodedValue = SMBUtil.readInt8(buffer, offset);

  @Benchmark
  int joinerWithStringDelimiter(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      dummy ^= JOINER_ON_STRING.join(components).length();
    }
    return dummy;
  }

  /** {@link Joiner} with a character delimiter. */
  @Benchmark
  int joinerWithCharacterDelimiter(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {

            int[] disconnectedStates = { 0, 4, 5, 6 };
            int[] connectedStates = { 1, 2, 3 };

            for (int state : disconnectedStates) {
                transport.setState(state);
                assertTrue(transport.isDisconnected(), "State " + state + " should be disconnected");
            }

            for (int state : connectedStates) {

    }
    return tmp;
  }

  @Benchmark
  int log10(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += BigIntegerMath.log10(positive[j], mode);
    }
    return tmp;
  }

  @Benchmark
  int sqrt(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += BigIntegerMath.sqrt(positive[j], mode).intValue();

    }

    @Test
    @DisplayName("Test haveCapability with multiple capability flags")
    void testHaveCapabilityMultipleFlags() {
        // Arrange
        int cap1 = 0x00000001;
        int cap2 = 0x00000002;
        int cap3 = 0x00000004;
        when(negotiationResponse.haveCapabilitiy(cap1)).thenReturn(true);
        when(negotiationResponse.haveCapabilitiy(cap2)).thenReturn(false);