package okhttp3.internal.http2.hpackjson

import okhttp3.internal.http2.Header
import okio.ByteString

/**
 * Representation of an individual case (set of headers and wire format). There are many cases for a
 * single story.  This class is used reflectively with Moshi to parse stories.
 */
data class Case(
  val seqno: Int = 0,
  val wire: ByteString? = null,
  val headers: List<Map<String, String>>,
) : Cloneable {

    assumeFalse(
      story === Story.MISSING,
      "Test stories missing, checkout git submodule",
    )

    val newCases = mutableListOf<Case>()
    for (case in story.cases) {
      hpackWriter.writeHeaders(case.headersList)
      newCases += case.copy(wire = bytesOut.readByteString())
    }

    testDecoder(story.copy(cases = newCases))
  }

  companion object {

[submodule "okhttp-hpacktests/src/test/resources/hpack-test-case"]
	path = okhttp-hpacktests/src/test/resources/hpack-test-case

!!! tip
    **GraphQL** solves some very specific use cases.

    It has **advantages** and **disadvantages** when compared to common **web APIs**.

    Make sure you evaluate if the **benefits** for your use case compensate the **drawbacks**. 🤓

## GraphQL Libraries

Here are some of the **GraphQL** libraries that have **ASGI** support. You could use them with **FastAPI**:

        switch (request.getPath()) {
            case "/v1/login/auth/":
                return new MockResponse().setResponseCode(200);
            case "/v1/check/version/":
                return new MockResponse().setResponseCode(200).setBody("version=9");
            case "/v1/profile/info":

You can declare the type of a path parameter in the function, using standard Python type annotations:

```Python hl_lines="7"
{!../../../docs_src/path_params/tutorial002.py!}
```

In this case, `item_id` is declared to be an `int`.

!!! check
    This will give you editor support inside of your function, with error checks, completion, etc.

Similar to the way you can [add `dependencies` to the *path operation decorators*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, you can add them to the `FastAPI` application.

In that case, they will be applied to all the *path operations* in the application:

=== "Python 3.9+"

    ```Python hl_lines="16"
    {!> ../../../docs_src/dependencies/tutorial012_an_py39.py!}
    ```

=== "Python 3.8+"

     *
     * ## Upstream
     *
     * In this case the current thread is assigned as the upstream reader. We read bytes from
     * upstream and copy them to both the file and to the buffer. Finally we release the upstream
     * reader lock and return the new bytes.
     *
     * ## The file
     *
     * In this case we copy bytes from the file to the [sink].
     *
     * ## The buffer
     *

        fmt.Println("Subroute:", GetSubroute(ctx))
        for {
            select {
            case <-ctx.Done():
                return nil
            case req, ok := <-in:
                if !ok {
                    break
                }           
                // Do something with payload
                out <- []byte("response")

### Return a Response Directly

The most common case would be [returning a Response directly as explained later in the advanced docs](../advanced/response-directly.md){.internal-link target=_blank}.

```Python hl_lines="8  10-11"
{!> ../../../docs_src/response_model/tutorial003_02.py!}
```