]
        }
    )


def test_get_invalid_one_header():
    response = client.get("/items/", headers={"X-Token": "invalid"})
    assert response.status_code == 400, response.text
    assert response.json() == {"detail": "X-Token header invalid"}


def test_get_invalid_second_header():
    response = client.get(
        "/items/", headers={"X-Token": "fake-super-secret-token", "X-Key": "invalid"}
    )

    user = User(username=oauth_header)
    return user


@app.get("/users/me")
def read_current_user(current_user: Optional[User] = Depends(get_current_user)):
    if current_user is None:
        return {"msg": "Create an account first"}
    return current_user


client = TestClient(app)


def test_security_api_key():
    response = client.get("/users/me", headers={"key": "secret"})

    q: Union[str, None] = None, skip: int = 0, limit: int = 100
):
    return {"q": q, "skip": skip, "limit": limit}


@app.get("/items/")
async def read_items(commons: Annotated[dict, Depends(common_parameters)]):
    return {"message": "Hello Items!", "params": commons}


@app.get("/users/")
async def read_users(commons: Annotated[dict, Depends(common_parameters)]):
    return {"message": "Hello Users!", "params": commons}

    get() = fullyQualifiedName.substringAfterLast(".")


internal
val JApiClass.packagePath: String
    get() = packageName.replace(".", "/")


internal
val JApiClass.packageName: String

            0, unhashables.e0(), 2, "hey you", 0, unhashables.e1());
    assertEquals(2, multimap.get(0).size());
    assertTrue(multimap.get(0).contains(unhashables.e0()));
    assertTrue(multimap.get(0).contains(unhashables.e1()));
    assertTrue(multimap.get(2).contains("hey you"));
  }

  public void testEquals() {
    new EqualsTester()

		Level:    zap.NewAtomicLevelAt(zap.FatalLevel),
		Encoding: "console",
	}
	cfg.Endpoints = etcdEndpoints
	cfg.CoreDNSPath = env.Get(EnvEtcdCoreDNSPath, kvs.Get(CoreDNSPath))
	// Default path prefix for all keys on etcd, other than CoreDNSPath.
	cfg.PathPrefix = env.Get(EnvEtcdPathPrefix, kvs.Get(PathPrefix))
	if etcdSecure {
		cfg.TLS = &tls.Config{
			RootCAs:                  rootCAs,
			PreferServerCipherSuites: true,

from fastapi.testclient import TestClient

app = FastAPI()


@app.get("/{repeated_alias}")
def get_parameters_with_repeated_aliases(
    path: str = Path(..., alias="repeated_alias"),
    query: str = Query(..., alias="repeated_alias"),
):
    return {"path": path, "query": query}


client = TestClient(app)


def test_get_parameters():
    response = client.get("/test_path", params={"repeated_alias": "test_query"})

    val response1 = get(server.url("/"))
    assertThat(response1.body.string()).isEqualTo("A")
    assertThat(response1.header("Allow")).isEqualTo("GET, HEAD")
    val response2 = get(server.url("/"))
    assertThat(response2.body.string()).isEqualTo("A")
    assertThat(response2.header("Allow")).isEqualTo("GET, HEAD, PUT")
  }

  @Test
  fun getHeadersReturnsCachedHopByHopHeaders() {
    server.enqueue(

    dt->AsyncWait(async_wait_status.get());
    // Prefer non cancelled errors to uncover real failures.
    if (TF_GetCode(async_wait_status.get()) != TF_OK &&
        (first_bad_status == nullptr ||
         TF_GetCode(first_bad_status.get()) == TF_CANCELLED)) {
      first_bad_status.reset(TF_NewStatus());
      TF_SetStatus(first_bad_status.get(), TF_GetCode(async_wait_status.get()),

      assertThat(ioe.cause!!).isInstanceOf<EOFException>()
    }
  }

  // TODO GET preferred order - with tests to confirm this
  // 1. successful fresh cached GET response
  // 2. unsuccessful (404, 500) fresh cached GET response
  // 3. successful network response
  // 4. successful stale cached GET response
  // 5. unsuccessful response
  @Test
  fun usesCache() {