import org.junit.Test;

/**
 * @author koichik
 */
public class MapsTest {

    /**
     * @throws Exception
     */
    @Test
    public void test() throws Exception {
        final Map<String, Integer> map = map("a", 1).$("b", 2).$("c", 3).$();
        assertThat(map.size(), is(3));
        assertThat(map.get("a"), is(1));
        assertThat(map.get("b"), is(2));
        assertThat(map.get("c"), is(3));
    }

     *
     * @param value
     *            The value
     */
    public void setValue(final T value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return value.toString();
    }

public class KuromojiReadingFormFilterFactory extends AbstractTokenFilterFactory {

    private final boolean useRomaji;

    public KuromojiReadingFormFilterFactory(IndexSettings indexSettings, Environment environment, String name, Settings settings) {
        super(indexSettings, name, settings);
        useRomaji = settings.getAsBoolean("use_romaji", false);
    }

    @Override
    public TokenStream create(TokenStream tokenStream) {

        .build()

    client.newCall(request).execute().use { response ->
      if (!response.isSuccessful) throw IOException("Unexpected code $response")
      println(response.body.string())
    }
  }

  private class ProgressRequestBody(
    private val delegate: RequestBody,
    private val progressListener: ProgressListener,
  ) : RequestBody() {

  }

  public void testToString() {
    assertEquals("foo", entry("foo", 1).toString());
    assertEquals("bar x 2", entry("bar", 2).toString());
  }

  public void testToStringNull() {
    assertEquals("null", entry(NE, 1).toString());
    assertEquals("null x 2", entry(NE, 2).toString());
  }

  public void testEquals() {
    assertEquals(control("foo", 1), entry("foo", 1));

    assertTrue(future.isDone());
    assertTrue(future.isCancelled());

    assertThrows(CancellationException.class, () -> future.get());
  }

  public void testFailedFuture(@Nullable String message) throws InterruptedException {
    assertTrue(future.isDone());
    assertFalse(future.isCancelled());

    assertTrue(latch.await(5, SECONDS));
    assertTrue(future.isDone());

        }
        System.arraycopy(buffer, bufferIndex, this.outputBuffer, 0, len);
        return len;
    }

    @Override
    public String toString() {
        return ("TransCallNamedPipeResponse[" + super.toString() + "]");
    }

    /**
     * Gets the length of the response data received from the named pipe.
     *
     * @return response data length
     */

    }

    @Override
    protected int readDataWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override
    public String toString() {
        return ("NtTransQuerySecurityResponse[" + super.toString() + "]");
    }

        }
    }

    /**
     * Returns whether the constructor is <code>public</code>.
     *
     * @param constructor the constructor (must not be {@literal null} or empty string)
     * @return whether the constructor is <code>public</code>
     */
    public static boolean isPublic(final Constructor<?> constructor) {
        assertArgumentNotNull("constructor", constructor);

Und dann verwenden wir das beim Erstellen der `FastAPI`-App.

Dann könnten Sie OpenAPI (einschließlich der Dokumentationsoberflächen) deaktivieren, indem Sie die Umgebungsvariable `OPENAPI_URL` auf einen leeren String setzen, wie zum Beispiel:

<div class="termy">

```console
$ OPENAPI_URL= uvicorn main:app

<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```