@Test
        @DisplayName("Should handle empty data in wire format")
        void testWriteBytesWireFormatEmptyData() {
            request.setData(new byte[0], 0, 0);

            byte[] buffer = new byte[256];
            int bytesWritten = request.writeBytesWireFormat(buffer, 0);

            assertEquals(48, bytesWritten); // Only header, no data
            assertEquals(49, SMBUtil.readInt2(buffer, 0)); // Structure size

	"github.com/minio/minio/internal/hash/sha256"
	"golang.org/x/crypto/blake2b"

	xioutil "github.com/minio/minio/internal/ioutil"
	"github.com/minio/minio/internal/logger"
)

// magic HH-256 key as HH-256 hash of the first 100 decimals of π as utf-8 string with a zero key.
var magicHighwayHash256Key = []byte("\x4b\xe7\x34\xfa\x8e\x23\x8a\xcd\x26\x3e\x83\xe6\xbb\x96\x85\x52\x04\x0f\x93\x5d\xa3\x9f\x44\x14\x97\xe0\x9d\x13\x22\xde\x36\xa0")

		n := len(strings.TrimRight(s[:len(b)-1], "/"))
		b[n] = 0 // Replace trailing slash with NUL terminator
	}
}

// fitsInBase256 reports whether x can be encoded into n bytes using base-256
// encoding. Unlike octal encoding, base-256 encoding does not require that the
// string ends with a NUL character. Thus, all n bytes are available for output.
//
// If operating in binary mode, this assumes strict GNU binary mode; which means

        DummyAndXBlock block = new DummyAndXBlock();
        TestSigningDigest digest = new TestSigningDigest();
        block.digest = digest;

        byte[] buf = new byte[256];
        int len = block.encode(buf, 0);

        assertTrue(len > 0);
        assertTrue(digest.called, "sign() should be called during encode");
        assertEquals(len, digest.lastLength);
    }

    void testDecodeMoreProcessingParsesBlobAndFlags() throws Exception {
        Smb2SessionSetupResponse resp = newResponse();

        byte[] buf = new byte[256];
        int headerStart = 0;
        long expectedSessionId = 0x1122334455667788L;
        buildHeader(buf, headerStart, NtStatus.NT_STATUS_MORE_PROCESSING_REQUIRED, 0x0001, expectedSessionId);

    }

    @Test
    @DisplayName("writeBytesWireFormat should write correct structure")
    void testWriteBytesWireFormat() {
        byte[] buffer = new byte[256];
        int offset = 64; // Start at offset to test proper indexing

        int written = request.writeBytesWireFormat(buffer, offset);

        // Verify bytes written
        assertEquals(24, written);

    public static final int CIPHER_AES128_CCM = 0x1;

    /**
     * AES 128 GCM
     */
    public static final int CIPHER_AES128_GCM = 0x2;

    /**
     * AES 256 CCM
     */
    public static final int CIPHER_AES256_CCM = 0x3;

    /**
     * AES 256 GCM
     */
    public static final int CIPHER_AES256_GCM = 0x4;

    private int[] ciphers;

    /**
     * Constructs an encryption negotiate context.
     *

        String newFilename = "newfile.txt";

        trans2FindNext2.reset(newResumeKey, newFilename);

        // Verify by writing parameters and checking the buffer
        byte[] buffer = new byte[256];
        int written = trans2FindNext2.writeParametersWireFormat(buffer, 0);

        // Check resume key at offset 6 (after sid and maxItems and informationLevel)
        int actualResumeKey = SMBUtil.readInt4(buffer, 6);

        trans2SetFileInfo = new Trans2SetFileInformation(config, TEST_FID, mockFileInfo);

        byte[] setupBuffer = new byte[256];
        byte[] paramBuffer = new byte[256];
        byte[] dataBuffer = new byte[256];

        int setupWritten = trans2SetFileInfo.writeSetupWireFormat(setupBuffer, 0);
        int paramWritten = trans2SetFileInfo.writeParametersWireFormat(paramBuffer, 0);

        // Support both AES-128 and AES-256 for CCM cipher
        int keyLength = getKeyLength();
        final AEADBlockCipher cipher;

        if (keyLength == 16) {
            // AES-128 CCM
            cipher = new CCMBlockCipher(new AESEngine());
        } else if (keyLength == 32) {
            // AES-256 CCM - Bouncy Castle supports AES-256 with same AESEngine