public unicode_string() {
            // Default constructor
        }

        /**
         * The actual length of the string in bytes.
         */
        public short length;
        /**
         * The maximum allocated length of the string in bytes.
         */
        public short maximum_length;
        /**
         * The buffer containing the Unicode characters.
         */

//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package json

import (
	"bufio"
	"bytes"
	"io"
	"runtime"
	"sync"

	"github.com/minio/minio/internal/bpool"
	"github.com/minio/minio/internal/s3select/jstream"
	"github.com/minio/minio/internal/s3select/sql"
)

        buf[0] = 0x34; // Low byte
        buf[1] = 0x12; // High byte
        int written = resp.readParameterWordsWireFormat(buf, 0);

        assertEquals(8, written, "Expected readParameterWordsWireFormat to advance 8 bytes");
        assertEquals(0x1234L, resp.getCount(), "Count should reflect value from buffer");
    }

    @Test
    public void testToStringContainsCount() {
        // Little-endian: count = 512 (0x0200)

//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package cmd

import (
	"archive/tar"
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"io"
	"io/fs"
	"os"
	"path"
	"runtime"
	"sync"
	"time"

	"github.com/cosnicolaou/pbzip2"
	"github.com/klauspost/compress/s2"

func (kvs KVS) MarshalJSON() ([]byte, error) {
	b := new(bytes.Buffer)
	b.Write([]byte("{"))
	for i, kv := range kvs {
		b.Write([]byte("\"" + kv.Key + "\"" + ":"))
		valBuf, err := json.Marshal(kv.Value)
		if err != nil {
			return nil, err
		}
		b.Write(valBuf)
		if i < len(kvs)-1 {
			b.Write([]byte(","))
		}
	}
	b.Write([]byte("}"))
	return b.Bytes(), nil
}

     */
    public SrvCopyChunkCopyResponse() {
    }

    private int chunksWritten;
    private int chunkBytesWritten;
    private int totalBytesWritten;

    /**
     * Gets the number of bytes written in the last chunk
     * @return the chunkBytesWritten
     */
    public int getChunkBytesWritten() {
        return this.chunkBytesWritten;
    }

    /**

```

Use `raw_data` instead of `data` to send pre-formatted strings without JSON encoding:

```python
yield ServerSentEvent(raw_data="plain text line", event="log")
```

## Stream bytes

To stream bytes, declare a `response_class=` of `StreamingResponse` or a sub-class, and use `yield` to return the data.

```python
from fastapi import FastAPI
from fastapi.responses import StreamingResponse

        SMBUtil.writeInt2(20, buffer, bufferIndex + 2);
        // Set buffer length (FileFsSizeInformation is 24 bytes)
        SMBUtil.writeInt4(24, buffer, bufferIndex + 4);

        response = spy(response);
        when(response.getHeaderStart()).thenReturn(0);

        // Write FileFsSizeInformation data (24 bytes)
        SMBUtil.writeInt8(1000000, buffer, 20); // Total allocation units

     * Gets the total content size of all documents in this list.
     *
     * @return the total content size in bytes
     */
    public long getContentSize() {
        return contentSize;
    }

    /**
     * Adds to the total content size of this document list.
     *
     * @param contentSize the content size to add in bytes
     */
    public void addContentSize(final long contentSize) {
        this.contentSize += contentSize;

        * In responses, the `set` will be converted to a `list`.
        * The generated schema will specify that the `set` values are unique (using JSON Schema's `uniqueItems`).
* `bytes`:
    * Standard Python `bytes`.
    * In requests and responses will be treated as `str`.
    * The generated schema will specify that it's a `str` with `binary` "format".
* `Decimal`:
    * Standard Python `Decimal`.