```txt
Hello, World from Flask!
```

Y si vas a <a href="http://localhost:8000/v2" class="external-link" target="_blank">http://localhost:8000/v2</a> verás el response de FastAPI:

```JSON
{
    "message": "Hello World"
}

    public void tearDown() {
        if (tempFile != null && tempFile.exists()) {
            tempFile.delete();
        }
    }

    @Test
    public void testMemoryBasedCacheConstructor() {
        byte[] data = "Hello, World!".getBytes();
        ContentCache cache = new ContentCache(data);

        assertNotNull(cache);
    }

    @Test
    public void testFileBasedCacheConstructor() throws IOException {

import okhttp3.Request
import org.junit.jupiter.api.Test

class SampleTest {
  private val server = MockWebServer()

  private val client = OkHttpClient()

  @Test
  fun passingTest() {
    assertThat("hello").isEqualTo("hello")
  }

  @Test
  fun testMockWebServer() {
    server.enqueue(MockResponse(body = "abc"))
    server.start()

    client.newCall(Request(url = server.url("/"))).execute().use {

            String originalString = "Hello World Test";
            byte[] allBytes = originalString.getBytes(StandardCharsets.UTF_16LE);
            int partialLength = "Hello World".getBytes(StandardCharsets.UTF_16LE).length;

            // When
            String result = Strings.fromUNIBytes(allBytes, 0, partialLength);

            // Then

    assertHash(679745764, murmur3_32().hashUnencodedChars("k"));
    assertHash(1510782915, murmur3_32().hashUnencodedChars("hell"));
    assertHash(-675079799, murmur3_32().hashUnencodedChars("hello"));
    assertHash(1935035788, murmur3_32().hashUnencodedChars("http://www.google.com/"));
    assertHash(
        -528633700, murmur3_32().hashUnencodedChars("The quick brown fox jumps over the lazy dog"));
  }

		t.Fatalf("Unable to create a file \"as-directory/as-file\", %s", err)
	}
	if err = xlStorage.AppendFile(t.Context(), "exists", "as-file", []byte("Hello, World")); err != nil {
		t.Fatalf("Unable to create a file \"as-file\", %s", err)
	}
	if err = xlStorage.AppendFile(t.Context(), "exists", "as-file-parent", []byte("Hello, World")); err != nil {

            .message("OK")
            .body("Hello".toResponseBody())
            .header("Content-Encoding", "piedpiper")
            .build()
        }.build()

    val response = client.newCall(Request("https://google.com/robots.txt".toHttpUrl())).execute()

    assertThat(response.header("Content-Encoding")).isEqualTo("piedpiper")
    assertThat(response.body.string()).isEqualTo("Hello")
  }

  @Test
  fun gzipThroughCall() {

/// note | Remarque

`JSONResponse` est elle-même une sous-classe de `Response`.

///

Et quand vous retournez une `Response`, **FastAPI** la transmet directement.

Elle ne fera aucune conversion de données avec les modèles Pydantic, elle ne convertira pas le contenu en un type quelconque.

      .build()

  @Test
  fun upgrade() {
    val socketHandler =
      MockSocketHandler()
        .apply {
          receiveRequest("client says hello\n")
          sendResponse("server says hello\n")
          receiveRequest("client says goodbye\n")
          sendResponse("server says goodbye\n")
          exhaustResponse()
          exhaustRequest()
        }

	}

	DB.Model(&User{}).Count(&count2)
	if count1 != count2 {
		t.Errorf("No user should not be deleted by invalid SQL")
	}
}

func TestSetAndGet(t *testing.T) {
	if value, ok := DB.Set("hello", "world").Get("hello"); !ok {
		t.Errorf("Should be able to get setting after set")
	} else if value.(string) != "world" {
		t.Errorf("Set value should not be changed")
	}

	if _, ok := DB.Get("non_existing"); ok {