# class "feature"
    assert is_uploadfile_sequence_annotation(list[str] | list[UploadFile])


def test_serialize_sequence_value_with_optional_list():
    """Test that serialize_sequence_value handles optional lists correctly."""
    from fastapi._compat import v2

    field_info = FieldInfo(annotation=list[str] | None)
    field = v2.ModelField(name="items", field_info=field_info)

This gives you a lot of **flexibility**. You can return any data type, override any data declaration or validation, etc.

It also gives you a lot of **responsibility**. You have to make sure that the data you return is correct, in the correct format, that it can be serialized, etc.

## Using the `jsonable_encoder` in a `Response` { #using-the-jsonable-encoder-in-a-response }

    assertEquals(1, (int) iter.peek());
    assertEquals(1, (int) iter.next());

    /*
     * We test peek() after various calls to make sure that one bad call doesn't interfere with its
     * ability to throw the correct exception in the future.
     */
    assertThrows(NoSuchElementException.class, iter::peek);
    assertThrows(NoSuchElementException.class, iter::peek);
    assertThrows(NoSuchElementException.class, iter::next);

    assertEquals(1, (int) iter.peek());
    assertEquals(1, (int) iter.next());

    /*
     * We test peek() after various calls to make sure that one bad call doesn't interfere with its
     * ability to throw the correct exception in the future.
     */
    assertThrows(NoSuchElementException.class, iter::peek);
    assertThrows(NoSuchElementException.class, iter::peek);
    assertThrows(NoSuchElementException.class, iter::next);

    }

    @Test
    public void test_static_method_signatures() {
        // Verify all public static methods exist with correct signatures
        try {
            // setObject(String, Object)
            Method setObjectMethod = WebApiUtil.class.getMethod("setObject", String.class, Object.class);

        // Should write FileInformation data + 6 bytes padding
        assertEquals(36, written); // 30 + 6

        // Verify encode was called with correct offset
        verify(mockFileInfo).encode(buffer, offset);
    }

    @Test
    @DisplayName("Test readSetupWireFormat returns 0")
    void testReadSetupWireFormat() {

        } finally {
            der.close();
        }
        return collector.toByteArray();
    }

    @Test
    @DisplayName("Round-trip: all fields set encodes and parses back correctly")
    void testRoundTripAllFields() throws Exception {
        ASN1ObjectIdentifier[] mechs = new ASN1ObjectIdentifier[] { OID_KRB, OID_NTLM };

## Recap { #recap }

You can add multiple body parameters to your *path operation function*, even though a request can only have a single body.

But **FastAPI** will handle it, give you the correct data in your function, and validate and document the correct schema in the *path operation*.

You can also declare singular values to be received as part of the body.

    assertEquals("correct", f.apply(new Object()));
    assertEquals("correct", f.apply(null));

    Function<@Nullable Object, @Nullable String> g = Functions.constant(null);
    assertThat(g.apply(2)).isNull();
    assertThat(g.apply(null)).isNull();

    new EqualsTester()
        .addEqualityGroup(f, Functions.constant("correct"))

    if (dividend >= 0) {
      return dividend / divisor;
    }

    /*
     * Otherwise, approximate the quotient, check, and correct if necessary. Our approximation is
     * guaranteed to be either exact or one less than the correct value. This follows from fact that
     * floor(floor(x)/i) == floor(x/i) for any real x and integer i != 0. The proof is not quite
     * trivial.
     */