SMBUtil.writeInt2(0x1111, buffer1, 20);
        SMBUtil.writeInt2(0x0210, buffer1, 22);

        response.decode(buffer1, 0, 24);
        assertEquals(0x11111111, response.getCapabilities(), "First decode capabilities");
        assertEquals(0x1111, response.getSecurityMode(), "First decode security mode");
        assertEquals(0x0210, response.getDialect(), "First decode dialect");

        byte[] wireData = new byte[] { 0x10, 0x00, // StructureSize (must be 16)
                0x01, // ShareType (DISK)
                0x00, // Reserved
                0x01, 0x00, 0x00, 0x00, // ShareFlags
                0x08, 0x00, 0x00, 0x00, // Capabilities
                (byte) 0xFF, 0x01, 0x1F, 0x00 // MaximalAccess
        };

        // When

	// but these seem to be the values agreed on by tools.
	s_IFMT   = 0xf000
	s_IFSOCK = 0xc000
	s_IFLNK  = 0xa000
	s_IFREG  = 0x8000
	s_IFBLK  = 0x6000
	s_IFDIR  = 0x4000
	s_IFCHR  = 0x2000
	s_IFIFO  = 0x1000
	s_ISUID  = 0x800
	s_ISGID  = 0x400
	s_ISVTX  = 0x200

	msdosDir      = 0x10
	msdosReadOnly = 0x01
)

    /**
     * Create new RDMA negotiation request
     */
    public RdmaNegotiateRequest() {
        // Initialize with default values
        this.minVersion = 0x0100; // SMB Direct 1.0
        this.maxVersion = 0x0100; // SMB Direct 1.0
        this.creditsRequested = RdmaCapabilities.DEFAULT_SEND_CREDIT_TARGET;
        this.preferredSendSize = RdmaCapabilities.DEFAULT_MAX_RECEIVE_SIZE;

    assertThat(
      mergeAdjacentRanges(
        listOf(
          Mapping(0x0232, 0x0232, TYPE_MAPPED, "a".encodeUtf8()),
          Mapping(0x0233, 0x0233, TYPE_VALID, ByteString.EMPTY),
          Mapping(0x0234, 0x0236, TYPE_VALID, ByteString.EMPTY),
          Mapping(0x0237, 0x0239, TYPE_VALID, ByteString.EMPTY),
          Mapping(0x023a, 0x023a, TYPE_MAPPED, "b".encodeUtf8()),
        ),
      ),
    ).containsExactly(

        // 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")

        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 })

	version(3.0)
]
interface netdfs
{
	import "../rpc.idl";

	const uint32_t DFS_VOLUME_FLAVOR_STANDALONE = 0x100;
	const uint32_t DFS_VOLUME_FLAVOR_AD_BLOB = 0x200;

	const uint32_t DFS_STORAGE_STATE_OFFLINE = 0x0001;
	const uint32_t DFS_STORAGE_STATE_ONLINE = 0x0002;
	const uint32_t DFS_STORAGE_STATE_ACTIVE = 0x0004;

	typedef struct {
		[string] wchar_t *entry_path;
	} DfsInfo1;

	typedef struct {
		uint32_t count;

     * Open file by its file ID
     */
    public static final int FILE_OPEN_BY_FILE_ID = 0x2000;
    /**
     * The file is being opened for backup intent
     */
    public static final int FILE_OPEN_FOR_BACKUP_INTENT = 0x4000;
    /**
     * Disable compression on the file
     */
    public static final int FILE_NO_COMPRESSION = 0x8000;
    /**

    hasher.putBytes(new byte[] {});
    hasher.putBytes(new byte[] {8});
    hasher.assertBytes(expected);
  }

  public void testShort() {
    TestHasher hasher = new TestHasher();
    hasher.putShort((short) 0x0201);
    hasher.assertBytes(new byte[] {1, 2});
  }

  public void testInt() {
    TestHasher hasher = new TestHasher();
    hasher.putInt(0x04030201);
    hasher.assertBytes(new byte[] {1, 2, 3, 4});
  }