*
 * @param <B> The concrete type of this builder (the 'self-type'). All the Builder methods of this
 *     class (such as {@link #named(String)}) return this type, so that Builder methods of more
 *     derived classes can be chained onto them without casting.
 * @param <G> The type of the generator to be passed to testers in the generated test suite. An
 *     instance of G should somehow provide an instance of the class under test, plus any other

        assertEquals(1, slf4jConfiguration.setRootLoggerLevelCallCount);
        assertEquals(Slf4jConfiguration.Level.ERROR, slf4jConfiguration.lastSetLevel);
    }

    // Mock classes for testing
    private static class MockInvokerRequest {
        private final boolean verbose;

        MockInvokerRequest(boolean verbose) {
            this.verbose = verbose;
        }

O middleware não precisa ser feito para o FastAPI ou Starlette para funcionar, desde que siga a especificação ASGI.

No geral, os middlewares ASGI são classes que esperam receber um aplicativo ASGI como o primeiro argumento.

Então, na documentação de middlewares ASGI de terceiros, eles provavelmente dirão para você fazer algo como:

```Python
from unicorn import UnicornMiddleware

    assertThat(Iterables.getOnlyElement(getCausalChain(sue))).isSameInstanceAs(sue);

    List<Throwable> causes = getCausalChain(ex);
    assertThrows(UnsupportedOperationException.class, () -> causes.add(new RuntimeException()));
  }

  public void testGetCasualChainNull() {
    assertThrows(NullPointerException.class, () -> getCausalChain(null));
  }

          public void onFailure(Throwable t) {}
        },
        directExecutor());
    assertThat(called[0]).isTrue();
  }

  // Avoid trouble with automatic mapping between JRE and Kotlin runtime classes.
  static class CustomRuntimeException extends RuntimeException {}

  public void testCatching() throws Exception {
    FluentFuture<?> f =
        FluentFuture.from(immediateFailedFuture(new CustomRuntimeException()))

        }
    }

    @Nested
    @DisplayName("Inheritance verification")
    class InheritanceVerification {

        @Test
        @DisplayName("should properly extend base classes")
        void testInheritance() {
            // Arrange
            SamrPolicyHandle ph = createMockPolicyHandle();

            // Act

 * sum that is used for purposes such as collecting statistics, not for fine-grained synchronization
 * control. Under low update contention, the two classes have similar characteristics. But under
 * high contention, expected throughput of this class is significantly higher, at the expense of
 * higher space consumption.
 *

    assertThat(network.nodeOrder()).isEqualTo(unordered());
    assertThat(network.nodes()).containsExactly(4, 1, 3);
  }

  // Sorting of user-defined classes

  @Test
  public void customComparator() {
    Comparator<NonComparableSuperClass> comparator =
        (left, right) -> left.value.compareTo(right.value);

    MutableGraph<NonComparableSuperClass> graph =

En utilisant seulement `BackgroundTasks` (et non `BackgroundTask`), il est possible de l'utiliser en tant que paramètre de *fonction de chemin d'accès* et de laisser **FastAPI** gérer le reste pour vous, comme en utilisant l'objet `Request` directement.

## Mais informações { #more-info }

Para aprender mais sobre as opções, verifique a documentação do Starlette para:

* [A classe `WebSocket`](https://www.starlette.dev/websockets/).