"input": "XL",
                }
            ],
            "body": {"title": "towel", "size": "XL"},
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["body", "size"],
                    "msg": "value is not a valid integer",

                    "msg": "Input should be a valid integer, unable to parse string as an integer",
                    "input": "foo",
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "value is not a valid integer",

import org.junit.jupiter.api.Assumptions.assumeFalse
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ArgumentsSource

/**
 * Tests for round-tripping headers through hpack.
 *
 * TODO: update hpack-test-case with the output of our encoder.
 * This test will hide complementary bugs in the encoder and decoder,
 * We should test that the encoder is producing responses that are
 */

    throw new UnsupportedOperationException();
  }

  private static final Joiner joiner = Joiner.on(", ");

  @Override
  protected void assertMoreInvariants(Map<K, V> map) {
    // TODO: can these be moved to MapInterfaceTest?
    for (Entry<K, V> entry : map.entrySet()) {
      assertEquals(entry.getKey() + "=" + entry.getValue(), entry.toString());
    }

### ¿Es la concurrencia mejor que el paralelismo?

¡No! Esa no es la moraleja de la historia.

La concurrencia es diferente al paralelismo. Y es mejor en escenarios **específicos** que implican mucha espera. Debido a eso, generalmente es mucho mejor que el paralelismo para el desarrollo de aplicaciones web. Pero no para todo.

/**
 * Tests representing the contract of {@link SortedMap}. Concrete subclasses of this base class test
 * conformance of concrete {@link SortedMap} subclasses to that contract.
 *
 * @author Jared Levy
 */
// TODO: Use this class to test classes besides ImmutableSortedMap.
@GwtCompatible
public abstract class SortedMapInterfaceTest<K, V> extends MapInterfaceTest<K, V> {

  protected SortedMapInterfaceTest(
      boolean allowsNullKeys,

  /** Test an empty collection. */
  ZERO(0),
  /** Test a one-element collection. */
  ONE(1),
  /** Test a three-element collection. */
  SEVERAL(3),
  /*
   * TODO: add VERY_LARGE, noting that we currently assume that the fourth
   * sample element is not in any collection
   */

  ANY(ZERO, ONE, SEVERAL);

  private final Set<Feature<? super Collection>> implied;

                logger.lifecycle("Removing transforms directory : $transformDir")
                delete { delete(transformDir) }
            }
    }
}


private
val scriptCacheDirNames =
    // TODO Remove gradle-kotlin-dsl* after a while
    listOf("scripts", "scripts-remapped", "gradle-kotlin-dsl", "gradle-kotlin-dsl-accessors", "kotlin-dsl")


private
fun scriptsCacheDirsUnder(cacheDir: File) =

Primeiro, você tem que importá-lo:

```Python hl_lines="4"
{!../../docs_src/body_fields/tutorial001.py!}
```

/// warning | "Aviso"

Note que `Field` é importado diretamente do `pydantic`, não do `fastapi` como todo o resto (`Query`, `Path`, `Body`, etc).

///

## Declare atributos do modelo

Você pode então utilizar `Field` com atributos do modelo:

```Python hl_lines="11-14"
{!../../docs_src/body_fields/tutorial001.py!}

  @Override
  protected abstract ListenableFuture<? extends V> delegate();

  @Override
  public void addListener(Runnable listener, Executor exec) {
    delegate().addListener(listener, exec);
  }

  // TODO(cpovirk): Use standard Javadoc form for SimpleForwarding* class and constructor
  /**
   * A simplified version of {@link ForwardingListenableFuture} where subclasses can pass in an