<img src="/img/tutorial/separate-openapi-schemas/image02.png">
</div>

This means that it will **always have a value**, it's just that sometimes the value could be `None` (or `null` in JSON).

That means that, clients using your API don't have to check if the value exists or not, they can **assume the field will always be there**, but just that in some cases it will have the default value of `None`.

import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.annotations.Provider;

/**
 * This interface supplies the API for providing feedback to the user from the {@code Mojo},
 * using standard Maven channels.
 * There should be no big surprises here, although you may notice that the methods accept
 * <code>java.lang.CharSequence</code> rather than <code>java.lang.String</code>. This is provided mainly as a

    mod.engine.dispose()


def test_crud_app(client: TestClient):
    # TODO: this warns that SQLModel.from_orm is deprecated in Pydantic v1, refactor
    # this if using obj.model_validate becomes independent of Pydantic v2
    with warnings.catch_warnings(record=True):
        warnings.simplefilter("always")
        # No heroes before creating
        response = client.get("heroes/")

- Fixes a bug where Services using finalizers may hold onto ClusterIP and/or NodePort allocated resources for longer than expected if the finalizer is removed using the status subresource ([#120657](https://github.com/kubernetes/kubernetes/pull/120657), [@aojea](https://github.com/aojea)) [SIG Network and Testing]

     *
     * @throws GeneralSecurityException
     */
    @Test
    void testCalculateMacArcfourHMACMD5() throws GeneralSecurityException {
        // Using a key with a known value for reproducibility
        SecretKeySpec key = new SecretKeySpec(new byte[16], "ARCFOUR");
        byte[] mac = PacMac.calculateMacArcfourHMACMD5(3, key, TEST_DATA);
        assertNotNull(mac);

import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;

import jcifs.CIFSException;
import jcifs.SmbTransport;
import jcifs.SmbTree;

/**
 * Tests for SmbSessionInternal interface using Mockito to exercise
 * method contracts, checked exceptions, and interactions with collaborators.
 */
@ExtendWith(MockitoExtension.class)
public class SmbSessionInternalTest {

    @Mock

If you declare it as is, because it is a singular value, **FastAPI** will assume that it is a query parameter.

But you can instruct **FastAPI** to treat it as another body key using `Body`:

{* ../../docs_src/body_multiple_params/tutorial003_an_py310.py hl[23] *}


In this case, **FastAPI** will expect a body like:

```JSON
{
    "item": {
        "name": "Foo",

    }

    @Override
    public E intern(E sample) {
      while (true) {
        // trying to read the canonical...
        @SuppressWarnings("rawtypes") // using raw types to avoid a bug in our nullness checker :(
        InternalEntry entry = map.getEntry(sample);
        if (entry != null) {
          Object canonical = entry.getKey();

@J2ktIncompatible
public final class EnumHashBiMap<K extends Enum<K>, V extends @Nullable Object>
    extends AbstractBiMap<K, V> {
  transient Class<K> keyTypeOrObjectUnderJ2cl;

  /**
   * Returns a new, empty {@code EnumHashBiMap} using the specified key type.
   *
   * @param keyType the key type
   */
  public static <K extends Enum<K>, V extends @Nullable Object> EnumHashBiMap<K, V> create(
      Class<K> keyType) {

    assertThrows(IOException.class, () -> reader.reset());
  }

  /**
   * Creates a CharSequenceReader wrapping the given CharSequence and tests that the reader produces
   * the same sequence when read using each type of read method it provides.
   */
  private static void assertReadsCorrectly(CharSequence charSequence) throws IOException {
    String expected = charSequence.toString();

    // read char by char