}

    @Test
    @DisplayName("Test writeParameterWordsWireFormat for primary NT transaction")
    void testWriteParameterWordsWireFormatPrimary() {
        byte[] dst = new byte[256];

        // Set up transaction parameters
        transaction.setMaxSetupCount((byte) 2);
        transaction.setTotalParameterCount(100);
        transaction.setTotalDataCount(200);

            when(mockLock.encode(any(byte[].class), anyInt())).thenReturn(24);

            Smb2LockRequest req = new Smb2LockRequest(mockConfig, testFileId, locks);
            byte[] buffer = new byte[256];

            int bytesWritten = req.writeBytesWireFormat(buffer, 0);

            // Verify structure
            assertEquals(48, SMBUtil.readInt2(buffer, 0)); // Structure size

     * @param klen the length of the key to use
     */
    public void init(final byte[] key, final int ki, final int klen) {
        s = new byte[256];

        for (i = 0; i < 256; i++) {
            s[i] = (byte) i;
        }

        for (i = j = 0; i < 256; i++) {
            j = j + key[ki + i % klen] + s[i] & 0xff;
            final byte t = s[i];
            s[i] = s[j];
            s[j] = t;
        }

        void testConcurrentEncoding() {
            TestCreateContextRequest request = new TestCreateContextRequest("CONCURRENT".getBytes(StandardCharsets.UTF_8));

            byte[] buffer1 = new byte[256];
            byte[] buffer2 = new byte[256];

            // Encode to different buffers
            int result1 = request.encode(buffer1, 0);
            int result2 = request.encode(buffer2, 50);

		return nil
	}
	if r.current.name != "" {
		if r.current.name >= s {
			return nil
		}
		r.current.name = ""
		r.current.metadata = nil
	}
	// temporary name buffer.
	tmp := make([]byte, 0, 256)
	for {
		if more, err := r.mr.ReadBool(); !more {
			switch err {
			case nil:
				r.err = io.EOF
				return io.EOF
			case io.EOF:
				r.err = io.ErrUnexpectedEOF
				return io.ErrUnexpectedEOF

	"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

        @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

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

        // Test with binary data containing all byte values
        byte[] data = new byte[256];
        for (int i = 0; i < 256; i++) {
            data[i] = (byte) i;
        }

        ContentCache cache = new ContentCache(data);

        try (InputStream stream = cache.getInputStream()) {
            for (int i = 0; i < 256; i++) {
                int byteValue = stream.read();