}
	}
}

func testCreate(t *testing.T, w *Writer, wt *WriteTest) {
	header := &FileHeader{
		Name:   wt.Name,
		Method: wt.Method,
	}
	if wt.Mode != 0 {
		header.SetMode(wt.Mode)
	}
	f, err := w.CreateHeader(header)
	if err != nil {
		t.Fatal(err)
	}
	_, err = f.Write(wt.Data)
	if err != nil {
		t.Fatal(err)
	}
}

    assertThat(request.url.toString()).isEqualTo("http://127.0.0.1/")
  }

  @Test fun testHostname() {
    val headers = headersOf("Host", "host-from-header.com")
    val socket =
      MockWebServerSocket(
        FakeSocket(
          localAddress =
            InetAddress.getByAddress(
              "host-from-address.com",

    public int size() {
        // Context header: 16 bytes
        // Name: 4 bytes ("RqLs")
        // Padding: 4 bytes (to align data to 8-byte boundary)
        // Data: 32 bytes (lease V1 structure)
        return 16 + 4 + 4 + 32;
    }

    @Override
    public int encode(byte[] dst, int dstIndex) {
        int start = dstIndex;

        // Write context header

            throw new SmbException("File operation exceeds file bounds");
        }
    }

    /**
     * Validate SMB header fields
     *
     * @param protocolId protocol identifier
     * @param structureSize structure size field
     * @param command command code
     * @throws SmbException if header is invalid
     */
    public void validateSmbHeader(int protocolId, int structureSize, int command) throws SmbException {

            context = new PreauthIntegrityNegotiateContext(mockConfig, null, new byte[16]);

            assertNull(context.getHashAlgos());
            assertEquals(20, context.size()); // 4 header + 16 salt
        }

        @Test
        @DisplayName("Should handle null salt")
        void testNullSalt() {
            int[] hashAlgos = { PreauthIntegrityNegotiateContext.HASH_ALGO_SHA512 };

    assert response.json() == {
        "detail": [
            {
                "type": "greater_than",
                "loc": ["body", "item", "price"],
                "msg": "Input should be greater than 0",
                "input": -3.0,
                "ctx": {"gt": 0.0},
            }
        ]
    }


def test_openapi_schema(client: TestClient):
    response = client.get("/openapi.json")

# Classes as Dependencies { #classes-as-dependencies }

Before diving deeper into the **Dependency Injection** system, let's upgrade the previous example.

## A `dict` from the previous example { #a-dict-from-the-previous-example }

In the previous example, we were returning a `dict` from our dependency ("dependable"):

{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[9] *}

  `performance` CPU governor.
* Vary the problem input size with `@Param`.
* Use the integrated profilers in JMH to dig deeper if benchmark results to not match your hypotheses:
    * Add `-prof gc` to the options to check whether the garbage collector runs during a microbenchmarks and skews

        CurlRequest request = new CurlRequest(Method.POST, "https://example.com");

        // Add multiple headers
        request.header("Accept", "application/json").header("Content-Type", "application/json").header("Authorization", "Bearer token123")
                .header("X-Custom-Header", "custom-value");

        assertNotNull(request);
    }

    @Test
    public void testGzipSetsCompressionToGzip() {

    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .header("Range", "bytes=0-")
        .build()
    val call = client.newCall(request)

    // The response is not decompressed.
    val response = call.execute()
    assertThat(response.header("Content-Encoding")).isEqualTo("gzip")
    assertThat(response.body.source().readByteString()).isEqualTo(