///

## Use cases { #use-cases }

Some use cases include:

* Converting non-JSON request bodies to JSON (e.g. <a href="https://msgpack.org/index.html" class="external-link" target="_blank">`msgpack`</a>).
* Decompressing gzip-compressed request bodies.
* Automatically logging all request bodies.

## Handling custom request body encodings { #handling-custom-request-body-encodings }

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 {

Of course, there are some cases where there's no problem in running the previous steps multiple times, in that case, it's a lot easier to handle.

/// tip

Also, keep in mind that depending on your setup, in some cases you **might not even need any previous steps** before starting your application.

In that case, you wouldn't have to worry about any of this. 🤷

///

You probably read before that you can set a default [Response Status Code](../tutorial/response-status-code.md){.internal-link target=_blank}.

But in some cases you need to return a different status code than the default.

## Use case { #use-case }

For example, imagine that you want to return an HTTP status code of "OK" `200` by default.

Those parameters are what **FastAPI** will use to "solve" the dependency.

In both cases, it will have:

* An optional `q` query parameter that is a `str`.
* A `skip` query parameter that is an `int`, with a default of `0`.
* A `limit` query parameter that is an `int`, with a default of `100`.

In both cases the data will be converted, validated, documented on the OpenAPI schema, etc.

## Use it { #use-it }

package utils

import (
	"testing"
)

func TestSourceDir(t *testing.T) {
	cases := []struct {
		file string
		want string
	}{
		{
			file: `C:/Users/name/go/pkg/mod/gorm.io/gorm@v1.2.3/utils/utils.go`,
			want: `C:/Users/name/go/pkg/mod/gorm.io/`,
		},
		{
			file: `C:/go/work/proj/gorm/utils/utils.go`,
			want: `C:/go/work/proj/gorm/`,
		},
		{
			file: `C:/go/work/proj/gorm_alias/utils/utils.go`,

		shouldPass bool
	}{
		// Test cases with invalid bucket names ( Test number 1-4 ).
		{".test", "", ObjectInfo{}, BucketNameInvalid{Bucket: ".test"}, false},
		{"---", "", ObjectInfo{}, BucketNameInvalid{Bucket: "---"}, false},
		{"ad", "", ObjectInfo{}, BucketNameInvalid{Bucket: "ad"}, false},
		// Test cases with valid but non-existing bucket names (Test number 5-6).

# Dependencies in path operation decorators { #dependencies-in-path-operation-decorators }

In some cases you don't really need the return value of a dependency inside your *path operation function*.

Or the dependency doesn't return a value.

But you still need it to be executed/solved.

For those cases, instead of declaring a *path operation function* parameter with `Depends`, you can add a `list` of `dependencies` to the *path operation decorator*.

   *
   * {@snippet :
   * // Falling back to a zero counter in case an exception happens when processing the RPC to fetch
   * // counters.
   * ListenableFuture<Integer> faultTolerantFuture =
   *     fetchCounters().catching(FetchException.class, x -> 0, directExecutor());
   * }
   *
   * <p>When selecting an executor, note that {@code directExecutor} is dangerous in some cases. See

      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 {
    private val RAW_DATA = arrayOf("raw-data")
  }