)
        .dns(dns)
        .build()

    server.enqueue(MockResponse())

    val url = server.url("/").newBuilder().host("localhost.localdomain").build()
    val call = client.newCall(Request(url = url))
    val response = call.execute()
    assertThat(response.isSuccessful).isTrue()

    val recordedRequest = server.takeRequest()
    assertThat(recordedRequest.handshakeServerNames).containsExactly(url.host)
  }

		wa := obj.(webhookAnalysis)
		row := table.Row{
			Cells: make([]table.Cell, 0),
		}
		row.Cells = append(row.Cells, table.NewCell(wa.Name), table.NewCell(wa.Revision))
		if wa.Injected {
			row.Cells = append(row.Cells, table.NewCell("✔", color.FgGreen))
		} else {
			row.Cells = append(row.Cells, table.NewCell("✘", color.FgRed))
		}
		row.Cells = append(row.Cells, table.NewCell(wa.Reason))
		return row
	})

/// tip | "Tipp"

Bevorzugen Sie die `Annotated`-Version, falls möglich.

///

```Python hl_lines="7  15"
{!> ../../docs_src/request_files/tutorial001_02_py310.py!}
```

////

//// tab | Python 3.8+ nicht annotiert

/// tip | "Tipp"

Bevorzugen Sie die `Annotated`-Version, falls möglich.

///

```Python hl_lines="9  17"

// LTYPEC spec3	{ outcode(int($1), &$2); }
	CALL	AX
	JCS	2(PC)
	JMP	*AX // JMP AX
	CALL	*foo(SB)
	JCS	2(PC)
	JMP	$4
	JCS	2(PC)
	JMP	label // JMP 16
	CALL	foo(SB)
//	CALL	(AX*4) // TODO: This line is silently dropped on the floor!
	CALL	foo+4(SB)(AX*4)
	CALL	*4(SP) // CALL 4(SP)
	CALL	*(AX) // CALL (AX)
	CALL	*(SP) // CALL (SP)
//	CALL	*(AX*4) // TODO: This line is silently dropped on the floor!

@ExperimentalOkHttpApi
abstract class ConnectionListener {
  /**
   * Invoked as soon as a call causes a connection to be started.
   */
  open fun connectStart(
    route: Route,
    call: Call,
  ) {}

  /**
   * Invoked when a connection fails to be established.
   */
  open fun connectFailed(
    route: Route,
    call: Call,
    failure: IOException,
  ) {}

  /**

        elif is_gen_callable(call) or is_async_gen_callable(call):
            solved = await solve_generator(
                call=call, stack=async_exit_stack, sub_values=solved_result.values
            )
        elif is_coroutine_callable(call):
            solved = await call(**solved_result.values)
        else:
            solved = await run_in_threadpool(call, **solved_result.values)

      if (e != null) {
        eventListener.requestFailed(call, e)
      } else {
        eventListener.requestBodyEnd(call, bytesRead)
      }
    }
    if (responseDone) {
      if (e != null) {
        eventListener.responseFailed(call, e)
      } else {
        eventListener.responseBodyEnd(call, bytesRead)
      }
    }
    return call.messageDone(this, requestDone, responseDone, e)
  }

        for (Element tr : children(classDoc.getMethodsTable(), "tr")) {
            List<Element> cells = children(tr, "td");
            if (cells.size() != 1) {
                throw new RuntimeException(String.format("Expected 1 cell in <tr>, found: %s", tr));
            }
            String methodName = cells.get(0).getTextContent().trim();

    runTest {
      val call = ClosableCall()

      supervisorScope {
        assertFailsWith<CancellationException> {
          coroutineScope {
            call.afterCallbackOnResponse = {
              coroutineContext.job.cancel()
            }
            call.executeAsync()
          }
        }
      }

      assertThat(call.canceled).isTrue()

            "h": 5,
            "w": 6,
            "x": 0,
            "y": 1
         },
         "id": 2,
         "interval": "5s",
         "options": {
            "legend": {
               "calcs": [
                  "last",
                  "max"
               ],
               "displayMode": "table"
            }
         },
         "pluginVersion": "v11.0.0",
         "targets": [
            {