* be created automatically.
     *
     * @param output The file to serialize the settings to, must not be {@code null}.
     * @param options The options to use for serialization, may be {@code null} to use the default values.
     * @param settings The settings to serialize, must not be {@code null}.
     * @throws IOException If the settings could not be serialized.
     */

     * created automatically.
     *
     * @param output The file to serialize the model to, must not be {@code null}.
     * @param options The options to use for serialization, may be {@code null} to use the default values.
     * @param model The model to serialize, must not be {@code null}.
     * @throws IOException If the model could not be serialized.
     */

        assertTrue(s.contains("hello"));
    }

    @Test
    @DisplayName("Should serialize and deserialize preserving message and cause")
    void testJavaSerialization() throws Exception {
        // Given
        SpnegoException original = new SpnegoException("serialize me", new IllegalArgumentException("iaex"));

        // When
        byte[] bytes;

     * the method returns.
     *
     * @param output The writer to serialize the toolchains to, must not be {@code null}.
     * @param options The options to use for serialization, may be {@code null} to use the default values.
     * @param toolchains The toolchains to serialize, must not be {@code null}.
     * @throws IOException If the toolchains could not be serialized.
     */

  "content": "hello"
}
```

## Pydantic `bytes` for Output Data { #pydantic-bytes-for-output-data }

You can also use `bytes` fields with `ser_json_bytes` in the model config for output data, and Pydantic will *serialize* the bytes as base64 when generating the JSON response.

{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:2,12:16,29,38:41] hl[16] *}

		if err != nil {
			return keys, err
		}
	}
	return keys, nil
}

// serialize will serialize the provided keys and values.
// The function will panic if keys/value slices aren't of equal length.
// Payload size can give an indication of expected payload size.
// If plSize is <= 0 it will be calculated.
func (x *xlMetaInlineData) serialize(plSize int, keys [][]byte, vals [][]byte) {
	if len(keys) != len(vals) {

    category=FastAPIDeprecationWarning,
    stacklevel=2,
)
class UJSONResponse(JSONResponse):
    """JSON response using the ujson library to serialize data to JSON.

    **Deprecated**: `UJSONResponse` is deprecated. FastAPI now serializes data
    directly to JSON bytes via Pydantic when a return type or response model is
    set, which is faster and doesn't need a custom response class.

    Read more in the

When you create a **FastAPI** *path operation* you can normally return any data from it: a `dict`, a `list`, a Pydantic model, a database model, etc.

If you declare a [Response Model](../tutorial/response-model.md) FastAPI will use it to serialize the data to JSON, using Pydantic.

If you don't declare a response model, FastAPI will use the `jsonable_encoder` explained in [JSON Compatible Encoder](../tutorial/encoder.md) and put it in a `JSONResponse`.

# Currently, there is no way to pass multiple cookies with the same name.
# The only way to pass multiple values for cookie params is to serialize them using

	// Set WantParts to indicate 3 parts
	finalChecksum.WantParts = 3

	// Test AppendTo serialization
	var serialized []byte
	serialized = finalChecksum.AppendTo(serialized, checksumCombined)

	// Use ChecksumFromBytes to deserialize the final checksum
	chksmOut := ChecksumFromBytes(serialized)
	if chksmOut == nil {
		t.Fatal("ChecksumFromBytes returned nil")
	}

	// Assert they are exactly equal