/// tip

Keep in mind that if you return a response directly instead of using the `Response` parameter, FastAPI will return it directly.

So, you will have to make sure your data is of the correct type. E.g. it is compatible with JSON, if you are returning a `JSONResponse`.

And also that you are not sending any data that should have been filtered by a `response_model`.

///

### More info { #more-info }

```

### 3. Failure after conversion
If the conversion is successful, but the generated model is wrong, then state what is wrong:

- Model produces wrong results and/or has lesser accuracy.
- Model produces correct results, but it is slower than expected.

### 4. (optional) RNN conversion support
If converting TF RNN to TFLite fused RNN ops, please prefix [RNN] in the title.

### 5. (optional) Any other info / logs

 * If this removes all of the warnings, this will not remove the feature from the setup and/or teardown and will leave behind an empty array
 * While it would be more technically correct to do so, the effort/complexity does not warrant it, since for the expected usage it makes
 * no difference.
 */

public class RemoveWarnings implements RestTestTransformByParentObject {

import static java.util.stream.Collectors.toList;

/**
 * Extracts Kotlin DSL runtime generated sources.
 *
 * Current implementation extracts these from the wrapper's API jars.
 * This is not correct as it should do this with the built distribution instead.
 *
 * Doing it correctly would require running a Gradle build with the full
 * distribution and extracting the generated api jar from its Gradle user home,

public class MultisetSetCountConditionallyTester<E> extends AbstractMultisetSetCountTester<E> {
  @Override
  void setCountCheckReturnValue(E element, int count) {
    assertTrue(
        "setCount() with the correct expected present count should return true",
        setCount(element, count));
  }

  @Override
  void setCountNoCheckReturnValue(E element, int count) {
    setCount(element, count);
  }

            // Act
            SmbNamedPipe pipe = new SmbNamedPipe("smb://server/IPC$/foo", flags, ctx());

            // Assert: observable properties still correct
            assertEquals(flags, pipe.getPipeType());
            assertEquals(SmbConstants.TYPE_NAMED_PIPE, pipe.getType());
        }
    }

    @Test

        boostQueryCommand = new BoostQueryCommand();
        boostQueryCommand.register();
    }

    @Test
    public void test_getQueryClassName() {
        // Test that getQueryClassName returns the correct class name
        assertEquals("BoostQuery", boostQueryCommand.getQueryClassName());
    }

    @Test
    public void test_execute_withTermQuery() {
        // Test executing BoostQuery with a TermQuery inside

     * encoded as four 0xFF bytes by {@code writeUTime}.
     */
    @ParameterizedTest(name = "fid={0}, lastWriteTime={1}")
    @MethodSource("validParams")
    @DisplayName("happy: writeParameterWordsWireFormat writes correct bytes")
    void testWriteParameterWordsWireFormat(int fid, long lastWriteTime, byte[] expected) {
        SmbComClose close = new SmbComClose(fid, lastWriteTime);
        byte[] buffer = new byte[10];

## About Starlette { #about-starlette }

You shouldn't pin the version of `starlette`.

Different versions of **FastAPI** will use a specific newer version of Starlette.

So, you can just let **FastAPI** use the correct Starlette version.

## About Pydantic { #about-pydantic }

Pydantic includes the tests for **FastAPI** with its own tests, so new versions of Pydantic (above `1.0.0`) are always compatible with FastAPI.

Vous verrez la documentation API automatique pour la sous‑application, n'incluant que ses propres _chemins d'accès_, tous sous le préfixe de sous‑chemin correct `/subapi` :

<img src="/img/tutorial/sub-applications/image02.png">