generated OpenAPI, but currently it doesn't affect the parsing of the data.
            """
        ),
    ] = "multipart/form-data",
    alias: Annotated[
        str | None,
        Doc(
            """
            An alternative name for the parameter field.

            This will be used to extract the data and for the generated OpenAPI.

    void testHashVariousInputSizes(String input) {
        // Given
        byte[] data = input.getBytes();

        // When
        MessageDigest md4 = Crypto.getMD4();
        MessageDigest md5 = Crypto.getMD5();
        byte[] md4Hash = md4.digest(data);
        byte[] md5Hash = md5.digest(data);

        // Then
        assertNotNull(md4Hash);
        assertNotNull(md5Hash);

    response = client.post(path, data={"p": ["hello", "world"]})
    assert response.status_code == 200
    assert response.json() == {"p": None}


@pytest.mark.parametrize(
    "path",
    ["/optional-list-alias", "/model-optional-list-alias"],
)
def test_optional_list_alias_by_alias(path: str):
    client = TestClient(app)
    response = client.post(path, data={"p_alias": ["hello", "world"]})

     * Constructs and validates a PAC from raw data using provided Kerberos keys.
     * @param data the raw PAC data bytes
     * @param keys map of Kerberos keys for signature validation
     * @throws PACDecodingException if the PAC data is malformed or signature validation fails
     */
    public Pac(byte[] data, Map<Integer, KerberosKey> keys) throws PACDecodingException {
        byte[] checksumData = data.clone();
        try {

    /**
     * Field name for access result data.
     */
    public static final String ACCESS_RESULT_DATA = "accessResultData";

    /**
     * Flag indicating whether the access result data has been initialized.
     */
    private boolean initializedData = false;

    /**
     * Initializes the access result with response data and result data.
     *

            searchPaging(data, form);
        });
    }

    /**
     * Sets up pagination data for search results.
     *
     * @param data the render data to populate
     * @param form the search form containing criteria
     */
    protected void searchPaging(final RenderData data, final SearchForm form) {
        // page navi

  const val FLAG_END_STREAM = 0x1 // Used for headers and data.
  const val FLAG_END_HEADERS = 0x4 // Used for headers and continuation.
  const val FLAG_END_PUSH_PROMISE = 0x4
  const val FLAG_PADDED = 0x8 // Used for headers and data.
  const val FLAG_PRIORITY = 0x20 // Used for headers.
  const val FLAG_COMPRESSED = 0x20 // Used for data.

  /** Lookup table for valid frame types. */
  private val FRAME_NAMES =

    data: list[int] = Depends(get_data),
):
    return {"user": user_data[0], "scopes": user_data[1], "data": data}


client = TestClient(app)


def test_normal():
    response = client.get("/user")
    assert response.json() == {
        "user": "john",
        "scopes": ["foo", "bar"],
        "data": [1, 2, 3],
    }


def test_override_data():

    private final byte[] credentialType;

    /**
     * Constructs a PAC credential type from raw data.
     * @param data the raw credential type data
     * @throws PACDecodingException if the credential type data is invalid
     */
    public PacCredentialType(final byte[] data) throws PACDecodingException {
        this.credentialType = data;
        if (!isCredentialTypeCorrect()) {

     */
    protected abstract String getActionRole();

    /**
     * Writes data to the specified file path.
     *
     * @param path the file path to write to
     * @param data the data to write
     */
    protected void write(final String path, final byte[] data) {
        validateFilePath(path);
        LdiFileUtil.write(path, data);
    }

    /**
     * Validates the file path.
     *