import okhttp3.Request;
import okhttp3.Response;

public class SampleHttpClient {
  private final OkHttpClient client;

  public SampleHttpClient() {
    client = new OkHttpClient.Builder().build();
  }

  public void makeCall(HttpUrl url) throws IOException {
    try (Response response = client.newCall(new Request(url, Headers.EMPTY, "GET", null)).execute()) {
      System.out.println(response.body().string());
    }
  }

            {"item_id": "baz", "owner_id": 42},
        ),
    ],
)
def test_read_user_item(client: TestClient, path, expected_json):
    response = client.get(path)
    assert response.status_code == 200
    assert response.json() == expected_json


def test_openapi_schema(client: TestClient):
    response = client.get("/openapi.json")
    assert response.status_code == 200
    assert response.json() == {

@pytest.fixture(
    name="client",
    params=[
        pytest.param("tutorial003_py39"),
        pytest.param("tutorial003_py310", marks=needs_py310),
    ],
)
def get_client(request: pytest.FixtureRequest):
    mod = importlib.import_module(f"docs_src.response_model.{request.param}")

    client = TestClient(mod.app)
    return client


def test_post_user(client: TestClient):
    response = client.post(

	if m.closed {
		return errors.New("mux client closed")
	}
	return m.sendLocked(msg)
}

// sendLocked the message. msg.Seq and msg.MuxID will be set.
// m.respMu must be held.
func (m *muxClient) sendLocked(msg message) error {
	dst := GetByteBufferCap(msg.Msgsize())
	msg.Seq = m.SendSeq
	msg.MuxID = m.MuxID
	msg.Flags |= m.BaseFlags
	if debugPrint {
		fmt.Println("Client sending", &msg, "to", m.parent.Remote)
	}

import javax.net.ssl.TrustManagerFactory
import javax.net.ssl.X509TrustManager
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.OkHttpClient
import okhttp3.Request
import org.junit.jupiter.api.Test
import org.mockserver.client.MockServerClient
import org.mockserver.configuration.Configuration
import org.mockserver.logging.MockServerLogger
import org.mockserver.model.HttpRequest.request
import org.mockserver.model.HttpResponse.response

  val clientTestRule = OkHttpClientTestRule()

  private var client = clientTestRule.newClientBuilder().build()

  @StartStop
  private val server = MockWebServer()

  val request by lazy { Request(server.url("/")) }

  @Test
  fun suspendCall() {
    runTest {
      server.enqueue(MockResponse(body = "abc"))

      val call = client.newCall(request)

      call.executeAsync().use {

{* ../../docs_src/request_form_models/tutorial002_an_py39.py hl[12] *}

Wenn ein Client versucht, einige zusätzliche Daten zu senden, erhält er eine **Error-<abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr>**.

Zum Beispiel, wenn der Client versucht, folgende Formularfelder zu senden:

* `username`: `Rick`
* `password`: `Portal Gun`

    ) -> dict[str, Any]:
        return {"item": item}

    client = TestClient(app)
    response = client.post("/items/?q=first", json={"value": "first", "price": 100})
    assert response.status_code == 200, response.text
    assert response.json() == {"item": {"value": "first", "price": 100}}

    response = client.post("/items/?q=other", json={"value": "other", "price": 100.5})

type TestSuiteCommon struct {
	serverType string
	testServer TestServer
	endPoint   string
	accessKey  string
	secretKey  string
	signer     signerType
	secure     bool
	client     *http.Client
}

type check struct {
	*testing.T
	testType string
}

// Assert - checks if gotValue is same as expectedValue, if not fails the test.
func (c *check) Assert(gotValue any, expectedValue any) {

import okhttp3.Protocol
import okhttp3.Request

object ExternalHttp2Example {
  @JvmStatic
  fun main(args: Array<String>) {
    val client =
      OkHttpClient
        .Builder()
        .protocols(listOf(Protocol.HTTP_2, Protocol.HTTP_1_1))
        .build()
    val call =
      client.newCall(
        Request
          .Builder()
          .url("https://www.google.ca/")
          .build(),
      )