/** Unicode capability */
    int CAP_UNICODE = 0x0004;
    /** Large files capability */
    int CAP_LARGE_FILES = 0x0008;
    /** NT SMBs capability */
    int CAP_NT_SMBS = 0x0010;
    /** RPC remote APIs capability */
    int CAP_RPC_REMOTE_APIS = 0x0020;
    /** 32-bit status codes capability */
    int CAP_STATUS32 = 0x0040;
    /** Level II oplocks capability */
    int CAP_LEVEL_II_OPLOCKS = 0x0080;

        .putByte((byte) 0x01)
        .putByte((byte) 0x00)
        .putByte((byte) 0x01)
        .putByte((byte) 0x00)
        .putByte((byte) 0x00)
        .putByte((byte) 0x00)
        .putByte((byte) 0x00);
    assertEquals(hashCode, hasher.hash().asLong());

    hasher = HASH_FN.newHasher();
    hasher
        .putChar((char) 0x0101)
        .putChar((char) 0x0100)
        .putChar((char) 0x0000)

        assertEquals(0x0002, SmbConstants.CAP_MPX_MODE);
        assertEquals(0x0004, SmbConstants.CAP_UNICODE);
        assertEquals(0x0008, SmbConstants.CAP_LARGE_FILES);
        assertEquals(0x0010, SmbConstants.CAP_NT_SMBS);
        assertEquals(0x0020, SmbConstants.CAP_RPC_REMOTE_APIS);
        assertEquals(0x0040, SmbConstants.CAP_STATUS32);
        assertEquals(0x0080, SmbConstants.CAP_LEVEL_II_OPLOCKS);

        // Hexdump.toHexString uses uppercase and produces only the specified width
        // Note: completionFilter is displayed with 4 hex chars, not 8
        assertTrue(result.contains("fid=0x0000"));
        assertTrue(result.contains("filter=0x0000")); // Only 4 hex chars are shown
        assertTrue(result.contains("watchTree=false"));
    }

    @Test
    @DisplayName("Test writeSetupWireFormat preserves other buffer content")

        .putByte((byte) 0x01)
        .putByte((byte) 0x00)
        .putByte((byte) 0x01)
        .putByte((byte) 0x00)
        .putByte((byte) 0x00)
        .putByte((byte) 0x00)
        .putByte((byte) 0x00);
    assertEquals(hashCode, hasher.hash().asLong());

    hasher = HASH_FN.newHasher();
    hasher
        .putChar((char) 0x0101)
        .putChar((char) 0x0100)
        .putChar((char) 0x0000)

    assertThat(
      mergeAdjacentRanges(
        listOf(
          Mapping(0x0041, 0x0041, TYPE_MAPPED, "a".encodeUtf8()),
          Mapping(0x0042, 0x0042, TYPE_MAPPED, "b".encodeUtf8()),
        ),
      ),
    ).containsExactly(
      Mapping(0x0041, 0x0041, TYPE_MAPPED, "a".encodeUtf8()),
      Mapping(0x0042, 0x0042, TYPE_MAPPED, "b".encodeUtf8()),
    )
  }

  @Test fun simplifyCanonicalizesType() {

    int FLAGS2_STATUS32 = 0x4000;
    /**
     * Strings are Unicode flag.
     */
    int FLAGS2_UNICODE = 0x8000;

    /**
     * No capabilities.
     */
    int CAP_NONE = 0x0000;
    /**
     * Raw mode transfers are supported capability.
     */
    int CAP_RAW_MODE = 0x0001;
    /**
     * Multiplex mode is supported capability.
     */
    int CAP_MPX_MODE = 0x0002;
    /**

            assertEquals("Unknown dialect", exception.getMessage());
        }

        @ParameterizedTest
        @ValueSource(ints = { 0x0000, 0x0100, 0x0201, 0x0303, 0x0400, 0xFFFF })
        @DisplayName("Should throw exception for invalid dialects")
        void testConstructorInvalidDialects(int dialect) {
            IllegalArgumentException exception =

        closeFlagsField.setAccessible(true);
        int finalFlags = (int) closeFlagsField.get(request);
        assertEquals(0x0000, finalFlags);

        // Verify wire format reflects final state
        byte[] buffer = new byte[256];
        request.writeBytesWireFormat(buffer, 0);

        assertEquals(0x0000, SMBUtil.readInt2(buffer, 2));
        byte[] wireFileId = new byte[16];
        System.arraycopy(buffer, 8, wireFileId, 0, 16);

        assertEquals(0x00, dst[dstIndex + 2]);
        assertEquals(0x00, dst[dstIndex + 3]);

        // Verify security information (4 bytes)
        assertEquals(securityInfo, SMBUtil.readInt4(dst, dstIndex + 4));
    }

    @ParameterizedTest
    @DisplayName("Test writeParametersWireFormat with various FID values")
    @ValueSource(ints = { 0x0000, 0x0001, 0x7FFF, 0xFFFF, 0x1234, 0xABCD })