}

    @Test
    @DisplayName("Should format with specific offset and length")
    void testHexdumpWithOffsetAndLength() {
        // Given
        byte[] data = createTestData(64);
        int offset = 16;
        int length = 32;

        // When
        String result = Hexdump.toHexString(data, offset, length);

        // Then
        assertNotNull(result);

        final int offset = readULong(src, index + 4);
        final byte[] buffer = new byte[length];
        System.arraycopy(src, offset, buffer, 0, length);
        return buffer;
    }

    static void writeULong(final byte[] dest, final int offset, final int ulong) {
        dest[offset] = (byte) (ulong & 0xff);
        dest[offset + 1] = (byte) (ulong >> 8 & 0xff);

        }
    }

    @BeforeEach
    void setUp() {
        smbComNtTransaction = new ConcreteSmbComNtTransaction();
    }

    @Test
    void testConstructor() {
        // Test if the offsets are initialized correctly by the constructor.
        assertEquals(69, smbComNtTransaction.primarySetupOffset, "primarySetupOffset should be initialized to 69");

	if lastAddr, ok := p.dataAddr[name]; ok && nameAddr.Offset < lastAddr {
		p.errorf("overlapping DATA entry for %s", name)
		return
	}
	p.dataAddr[name] = nameAddr.Offset + int64(sz)

	switch valueAddr.Type {
	case obj.TYPE_CONST:
		switch sz {
		case 1, 2, 4, 8:
			nameAddr.Sym.WriteInt(p.ctxt, nameAddr.Offset, int(sz), valueAddr.Offset)
		default:
			p.errorf("bad int size for DATA argument: %d", sz)

        // Security buffer offset and length
        SMBUtil.writeInt2(128, buffer, offset + 56); // Offset
        SMBUtil.writeInt2(0, buffer, offset + 58); // Length

        // Negotiate context offset
        SMBUtil.writeInt4(144, buffer, offset + 60); // Point to contexts

        // Add negotiate contexts at offset 144
        int ctxOffset = 144;

        @DisplayName("Should encode with offset correctly")
        void testEncodeWithOffset() {
            String path = "\\\\test";
            int maxReferralLevel = 5;
            buffer = new DfsReferralRequestBuffer(path, maxReferralLevel);

            int offset = 10;
            byte[] dst = new byte[offset + buffer.size()];
            int bytesEncoded = buffer.encode(dst, offset);

        assertEquals(offset, getFieldValue(write, "offset"), "Offset should match constructor arg");
        assertEquals(remaining, getFieldValue(write, "remaining"), "Remaining should match constructor arg");
        assertEquals(buffer, getFieldValue(write, "b"), "Buffer reference should be set");
        assertEquals(off, getFieldValue(write, "off"), "Off should match constructor arg");

    private long offset;

    /**
     * Constructs a seek response.
     *
     * @param config the configuration
     */
    public SmbComSeekResponse(final Configuration config) {
        super(config);
    }

    /**
     * Gets the current file offset after the seek operation.
     *
     * @return the offset
     */
    public long getOffset() {

        this.writeFlags = writeFlags;
    }

    /**
     * Sets the file offset where the write operation should begin.
     *
     * @param offset the offset to set
     */
    public void setOffset(final long offset) {
        this.offset = offset;
    }

    /**
     * Add RDMA channel information for direct memory access
     *

    }
    h1 ^= mixK1(k1);
    return fmix(h1, len);
  }

  private static int getIntLittleEndian(byte[] input, int offset) {
    return Ints.fromBytes(input[offset + 3], input[offset + 2], input[offset + 1], input[offset]);
  }

  private static int mixK1(int k1) {
    k1 *= C1;
    k1 = Integer.rotateLeft(k1, 15);
    k1 *= C2;
    return k1;
  }