}
                    processArgs.add(String.join(" ", Arrays.asList(input.args())));
                    builder.command(processArgs);
                    builder.directory(shellContext.cwd.get().toFile());
                    Process process = builder.start();
                    Thread out = new Thread(new StreamGobbler(process.getInputStream(), shellContext.writer));

    } catch (e: IOException) {
      Platform.get().log("Saving cookies failed for " + url.resolve("/...")!!, WARN, e)
    }
  }

  override fun loadForRequest(url: HttpUrl): List<Cookie> {
    val cookieHeaders =
      try {
        // The RI passes all headers. We don't have 'em, so we don't pass 'em!
        cookieHandler.get(url.toUri(), emptyMap<String, List<String>>())
      } catch (e: IOException) {

            "CDN", "CH", "ID", "DNT", "DNS", "DPR", "ECT", "GPC", "HTTP2", "IP", "MD5", "P3P",
            "RTT", "TE", "UA", "UID", "URL", "WWW", "XSS");

    for (Field field : httpHeadersFields()) {
      assertThat(field.get(null))
          .isEqualTo(upperToHttpHeaderName(field.getName(), specialCases, uppercaseAcronyms));
    }
  }

  // Tests that there are no duplicate HTTP header names

    public void round(Blackhole bh) {
        Rounding.Prepared rounder = rounderBuilder.get();
        for (int i = 0; i < dates.length; i++) {
            bh.consume(rounder.round(dates[i]));
        }
    }

    @Benchmark
    public void nextRoundingValue(Blackhole bh) {
        Rounding.Prepared rounder = rounderBuilder.get();
        for (int i = 0; i < dates.length; i++) {

from fastapi import FastAPI, Request

app = FastAPI(root_path="/api/v1")


@app.get("/app")
def read_main(request: Request):

    tags: set[str] = set()


@app.post("/items/", tags=["items"])
async def create_item(item: Item) -> Item:
    return item


@app.get("/items/", tags=["items"])
async def read_items():
    return [{"name": "Foo", "price": 42}]


@app.get("/users/", tags=["users"])
async def read_users():

            }

            final Path resolved = Paths.get(exportPath, sanitized.toString()).normalize();
            final Path baseDir = Paths.get(exportPath).normalize();
            if (!resolved.startsWith(baseDir)) {
                logger.warn("Path traversal detected: url={}, resolved={}", url, resolved);
                return Paths.get(exportPath, "_invalid", hashString(url) + formatter.getFileExtension());
            }

              closed.set(true)
              super.close()
            }
          }.buffer()
        }
      }
    assertThat(body.string()).isEqualTo("hello")
    assertThat(closed.get()).isTrue()
  }

  @Test
  fun readerEmpty() {
    val body = body("")
    assertThat(exhaust(body.charStream())).isEqualTo("")
  }

  @Test
  fun readerLooksLikeBomButTooShort() {

def test_openapi_schema(client: TestClient):
    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text
    assert response.json() == snapshot(
        {
            "openapi": "3.1.0",
            "info": {"title": "FastAPI", "version": "0.1.0"},
            "paths": {
                "/items/{item_id}": {
                    "get": {
                        "responses": {

from fastapi import FastAPI

app = FastAPI()


@app.get("/users/me")
async def read_user_me():
    return {"user_id": "the current user"}


@app.get("/users/{user_id}")
async def read_user(user_id: str):