}

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    Table<String, Integer, Character> table = HashBasedTable.create();
    table.put("foo", 1, 'a');
    table.put("bar", 1, 'b');
    table.put("foo", 3, 'c');
    return unmodifiableTable(table).rowMap();
  }

  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    Table<String, Integer, String> table = HashBasedTable.create();
    table.put("foo", 1, "apple");
    table.put("bar", 1, "banana");
    table.put("foo", 3, "cat");
    return transformValues(table, TableCollectionTest.FIRST_CHARACTER).rowMap();
  }

  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    Table<Integer, String, Character> table = HashBasedTable.create();
    table.put(1, "foo", 'a');
    table.put(1, "bar", 'b');
    table.put(3, "foo", 'c');
    return unmodifiableTable(table).columnMap();
  }

This would mean that **FastAPI** would expect a body similar to:

```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"
    }
}
```

Again, doing just that declaration, with **FastAPI** you get:

    assertThrows(NegativeArraySizeException.class, () -> Atomics.newReferenceArray(-1));
  }

  public void testNewReferenceArray_withStringArray() throws Exception {
    String[] array = {"foo", "bar", "baz"};
    AtomicReferenceArray<String> refArray = Atomics.newReferenceArray(array);
    for (int i = 0; i < array.length; ++i) {
      assertThat(refArray.get(i)).isEqualTo(array[i]);
    }

    assertThat(new ClassInfo(FILE, "a/b/Bar$Foo.class", classLoader).getSimpleName())
        .isEqualTo("Foo");
    assertThat(new ClassInfo(FILE, "a/b/Bar$1.class", classLoader).getSimpleName()).isEqualTo("");
    assertThat(new ClassInfo(FILE, "a/b/Bar$Foo.class", classLoader).getSimpleName())
        .isEqualTo("Foo");
    assertThat(new ClassInfo(FILE, "a/b/Bar$1.class", classLoader).getSimpleName()).isEqualTo("");

Ensuite, avec une URL comme :

```
http://localhost:8000/items/?q=foo&q=bar
```

vous recevriez les valeurs des multiples paramètres de requête `q` (`foo` et `bar`) dans une `list` Python à l’intérieur de votre fonction de *chemin d'accès*, dans le *paramètre de fonction* `q`.

Donc, la réponse pour cette URL serait :

```JSON
{
  "q": [
    "foo",
    "bar"
  ]
}
```

/// tip | Astuce

    return Multimaps.forMap(map).asMap();
  }

  @Override
  protected Map<String, Collection<Integer>> makePopulatedMap() {
    Map<String, Integer> map = new HashMap<>();
    map.put("foo", 1);
    map.put("bar", 2);
    map.put("cow", 3);
    return Multimaps.forMap(map).asMap();
  }

  @Override
  public void testEntrySetRemoveAllNullFromEmpty() {
    try {
      super.testEntrySetRemoveAllNullFromEmpty();

    assertThat(requestsMade.size).isEqualTo(1)
  }

  @Test
  fun outOfOrderResponses() {
    val firstResponseCode = AtomicInteger()
    val secondResponseCode = AtomicInteger()
    val secondRequest = "/bar"
    val firstRequest = "/foo"
    val latch = CountDownLatch(1)
    val dispatcher: Dispatcher =
      object : Dispatcher() {
        override fun dispatch(request: RecordedRequest): MockResponse {

    // Plus for spaces
    assertEscaping(e, "+", ' ');
    assertEscaping(e, "%2B", '+');

    assertThat(e.escape("safe with spaces")).isEqualTo("safe+with+spaces");
    assertThat(e.escape("foo@bar.com")).isEqualTo("foo%40bar.com");
  }

  public void testUrlPathSegmentEscaper() {
    UnicodeEscaper e = (UnicodeEscaper) urlPathSegmentEscaper();
    assertPathEscaper(e);
    assertUnescaped(e, '+');
  }