Parce que nous utilisons une URL relative, si votre API se trouvait à `https://example.com/`, alors elle ferait référence à `https://example.com/token`. Mais si votre API se trouvait à `https://example.com/api/v1/`, alors elle ferait référence à `https://example.com/api/v1/token`.

        SmbFilenameFilter filter = (d, n) -> n.equalsIgnoreCase("hello.txt");
        assertTrue(filter.accept(dir, "Hello.TXT"));
    }

    @Test
    void acceptReturnsFalseWhenNameDoesNotMatch() throws Exception {
        SmbFile dir = Mockito.mock(SmbFile.class);
        SmbFilenameFilter filter = (d, n) -> n.equalsIgnoreCase("hello.txt");
        assertFalse(filter.accept(dir, "world.txt"));
    }

    @Test

		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 {

flask_app = Flask(__name__)


@flask_app.route("/")
def flask_main():
    name = request.args.get("name", "World")
    return f"Hello, {escape(name)} from Flask!"


app = FastAPI()


@app.get("/v2")
def read_main():
    return {"message": "Hello World"}

        override fun source(): BufferedSource {
          val source = Buffer().writeUtf8("hello")
          return object : ForwardingSource(source) {
            @Throws(IOException::class)
            override fun close(): Unit = throw IOException("Broken!")
          }.buffer()
        }
      }
    assertThat(body.source().readUtf8()).isEqualTo("hello")
    body.close()
  }

  @Test
  fun unicodeText() {

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 {

def test_orjson_response_emits_deprecation_warning():
    with pytest.warns(FastAPIDeprecationWarning, match="ORJSONResponse is deprecated"):
        ORJSONResponse(content={"hello": "world"})


# UJSON


def _make_ujson_app() -> FastAPI:
    with warnings.catch_warnings():
        warnings.simplefilter("ignore", FastAPIDeprecationWarning)

	b = bytes.TrimPrefix(b, []byte("Goodbye,"))
	b = bytes.TrimPrefix(b, []byte("See ya,"))
	fmt.Printf("Hello%s", b)
	// Output: Hello, world!
}

func ExampleTrimSpace() {
	fmt.Printf("%s", bytes.TrimSpace([]byte(" \t\n a lone gopher \n\t\r\n")))
	// Output: a lone gopher
}

func ExampleTrimSuffix() {
	var b = []byte("Hello, goodbye, etc!")
	b = bytes.TrimSuffix(b, []byte("goodbye, etc!"))

            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

@router.route("/items/")
def read_items(request: Request):
    return JSONResponse({"hello": "world"})


app.include_router(router)

client = TestClient(app)


def test_sub_router():
    response = client.get("/items/")
    assert response.status_code == 200, response.text