public void testIn_compilesWithExplicitSupertype() {
    Collection<Number> nums = ImmutableSet.of();
    Predicate<Number> p1 = Predicates.in(nums);
    Predicate<Object> p2 = Predicates.<Object>in(nums);
    // The next two lines are not expected to compile.
    // Predicate<Integer> p3 = Predicates.in(nums);
    // Predicate<Integer> p4 = Predicates.<Integer>in(nums);
  }

  @J2ktIncompatible
  @GwtIncompatible // NullPointerTester

          }
        };
    assertEquals(2, FluentIterable.from(iterable).size());
  }

  public void testSize_collectionDoesntIterate() {
    List<Integer> nums = asList(1, 2, 3, 4, 5);
    List<Integer> collection =
        new ArrayList<Integer>(nums) {
          @Override
          public Iterator<Integer> iterator() {
            throw new AssertionFailedError("Don't iterate me!");
          }
        };

        };
    assertEquals(2, Iterables.size(iterable));
  }

  @SuppressWarnings("serial")
  public void testSize_collection_doesntIterate() {
    List<Integer> nums = asList(1, 2, 3, 4, 5);
    List<Integer> collection =
        new ArrayList<Integer>(nums) {
          @Override
          public Iterator<Integer> iterator() {
            throw new AssertionFailedError("Don't iterate me!");
          }
        };

    padding: 0 0.25rem;
}

.input-hint {
    font-size: 0.6875rem;
    color: #8993a4;
}

.char-counter {
    font-size: 0.6875rem;
    color: #8993a4;
    font-variant-numeric: tabular-nums;
}

.char-counter.warning {
    color: #ff991f;
}

.char-counter.danger {
    color: #de350b;
}

/* ============================================
   Responsive adjustments

    assertThat(Enums.getIfPresent(TestEnum.class, "POODLE")).hasValue(TestEnum.POODLE);

    assertThat(Enums.getIfPresent(TestEnum.class, "CHEETO")).isPresent();
    assertThat(Enums.getIfPresent(TestEnum.class, "HONDA")).isPresent();
    assertThat(Enums.getIfPresent(TestEnum.class, "POODLE")).isPresent();

    assertThat(Enums.getIfPresent(TestEnum.class, "CHEETO")).hasValue(TestEnum.CHEETO);

* ✨ Add support for tags with Enums. PR [#4468](https://github.com/tiangolo/fastapi/pull/4468) by [@tiangolo](https://github.com/tiangolo). New docs: [Path Operation Configuration - Tags with Enums](https://fastapi.tiangolo.com/tutorial/path-operation-configuration/#tags-with-enums).

Je pense que `Union[SomeType, None]` est plus explicite quant à sa signification.

Il ne s'agit que des mots et des noms. Mais ces mots peuvent influencer la manière dont vous et vos coéquipiers pensez au code.

À titre d'exemple, prenons cette fonction :

```python
from typing import Optional


def say_hi(name: Optional[str]):

<img src="/img/tutorial/generate-clients/image06.png">

Dans ce cas, vous avez :

* `ItemsService`
* `UsersService`

### Noms des méthodes du client { #client-method-names }

À l’heure actuelle, les noms de méthodes générés comme `createItemItemsPost` ne sont pas très propres :

```TypeScript
ItemsService.createItemItemsPost({name: "Plumbus", price: 5})
```

Serán añadidas al esquema de OpenAPI y usadas por las interfaces de documentación automática:

<img src="/img/tutorial/path-operation-configuration/image01.png">

### Tags con Enums { #tags-with-enums }

Si tienes una gran aplicación, podrías terminar acumulando **varias tags**, y querrías asegurarte de que siempre uses la **misma tag** para *path operations* relacionadas.

Eles serão adicionados ao esquema OpenAPI e usados pelas interfaces de documentação automática:

<img src="/img/tutorial/path-operation-configuration/image01.png">

### Tags com Enums { #tags-with-enums }

Se você tem uma grande aplicação, você pode acabar acumulando **várias tags**, e você gostaria de ter certeza de que você sempre usa a ** mesma tag** para *operações de rota* relacionadas.