}

  @Override
  protected Map<String, Integer> makePopulatedMap() {
    Table<String, Character, Integer> table = HashBasedTable.create();
    table.put("one", 'a', 1);
    table.put("two", 'a', 2);
    table.put("three", 'a', 3);
    table.put("four", 'b', 4);
    return unmodifiableTable(table).column('a');
  }

        ImmutableListMultimap.<Integer, String>builder()
            .putAll(3, "one", "two")
            .put(5, "three")
            .put(4, "four")
            .build();
    ImmutableListMultimap<Integer, String> index =
        FluentIterable.from(asList("one", "two", "three", "four"))
            .index(
                new Function<String, Integer>() {
                  @Override

 * good reference implementation. As with {@code IteratorTester}, a concrete subclass must provide
 * target iterators on demand. It also requires three additional constructor parameters: {@code
 * elementsToInsert}, the elements to be passed to {@code set()} and {@code add()} calls; {@code

  @Override
  public SampleElements<Entry<String, String>> samples() {
    return new SampleElements<>(
        mapEntry("one", "January"),
        mapEntry("two", "February"),
        mapEntry("three", "March"),
        mapEntry("four", "April"),
        mapEntry("five", "May"));
  }

  @Override
  public Map<String, String> create(Object... entries) {
    @SuppressWarnings("unchecked")

      ++classesInitialized;
    }
  }

  private static class C {
    static {
      ++classesInitialized;
    }
  }

  public void testInitialize() {
    assertEquals("This test can't be included twice in the same suite.", 0, classesInitialized);

    Reflection.initialize(A.class);
    assertEquals(1, classesInitialized);

    Reflection.initialize(
        A.class, // Already initialized (above)

    }

    void report(int runCount, List<TestDescriptorInternal> activeDescriptors) {
        String report = "================\n"
            + "Test jvm exited unexpectedly.\n"
            + "Test jvm system exit trace (run: "
            + runCount
            + ")\n"
            + activeDescriptors.stream()
                .filter(d -> d.getId() instanceof CompositeIdGenerator.CompositeId)

        }
        // ensure file is open
        try (SmbFileHandleImpl fd = ensureOpen(); SmbTreeHandleImpl th = fd.getTree()) {

            if (log.isTraceEnabled()) {
                log.trace("read: fid=" + fd + ",off=" + off + ",len=" + len);
            }

            final int type = this.file.getType();
            int r, n;

    List<Byte> one = Arrays.asList((byte) 1);
    assertThat(Bytes.toArray(one)).isEqualTo(ARRAY1);

    byte[] array = {(byte) 0, (byte) 1, (byte) 0x55};

    List<Byte> three = Arrays.asList((byte) 0, (byte) 1, (byte) 0x55);
    assertThat(Bytes.toArray(three)).isEqualTo(array);

    assertThat(Bytes.toArray(Bytes.asList(array))).isEqualTo(array);
  }

  public void testToArray_threadSafe() {

{* ../../docs_src/body_nested_models/tutorial004_py310.py hl[18] *}

Esto significaría que **FastAPI** esperaría un cuerpo similar a:

```JSON
{
    "name": "Foo",
    "description": "The pretender",
    "price": 42.0,
    "tax": 3.2,
    "tags": ["rock", "metal", "bar"],
    "image": {
        "url": "http://example.com/baz.jpg",
        "name": "The Foo live"
    }
}
```

```JSON
{
    "name": "Foo",
    "description": "An optional description",
    "price": 45.2,
    "tax": 3.5
}
```

...as `description` and `tax` are optional (with a default value of `None`), this JSON "`object`" would also be valid:

```JSON
{
    "name": "Foo",
    "price": 45.2
}
```

## Declare it as a parameter { #declare-it-as-a-parameter }