@app.get("/item", response_model=Item)
async def read_item():
    return {
        "id": uuid.uuid4(),
        "name": "Island In The Moon",
        "price": 12.99,
        "description": "A place to be playin' and havin' fun",
        "tags": ["breater"],
    }


client = TestClient(app)


def test_annotations():
    response = client.get("/item")
    assert response.status_code == 200, response.text

import java.util.concurrent.TimeUnit
import okhttp3.OkHttpClient
import okhttp3.Request

class CancelCall {
  private val executor = Executors.newScheduledThreadPool(1)
  private val client = OkHttpClient()

  fun run() {
    val request =
      Request
        .Builder()
        .url("http://httpbin.org/delay/2") // This URL is served with a 2 second delay.
        .build()

    val startNanos = System.nanoTime()

  @ParameterizedTest
  @ArgumentsSource(StoriesTestProvider::class)
  fun testGoodDecoderInterop(story: Story) {
    assumeFalse(
      story === Story.MISSING,
      "Test stories missing, checkout git submodule",
    )
    testDecoder(story)
  }

  internal class StoriesTestProvider : SimpleProvider() {
    override fun arguments(): List<Any> = createStories(HpackJsonUtil.storiesForCurrentDraft())
  }

import java.net.URI

/**
 * A proxy selector that always returns the [Proxy.NO_PROXY].
 */
object NullProxySelector : ProxySelector() {
  override fun select(uri: URI?): List<Proxy> {
    requireNotNull(uri) { "uri must not be null" }
    return listOf(Proxy.NO_PROXY)
  }

  override fun connectFailed(
    uri: URI?,
    sa: SocketAddress?,
    ioe: IOException?,
  ) {
  }

class Jdk8WithJettyBootPlatformTest {
  @RegisterExtension
  val platform = PlatformRule()

  @Test
  fun testBuildsWithJettyBoot() {
    assumeTrue(System.getProperty("java.specification.version") == "1.8")
    platform.assumeJettyBootEnabled()
    assertThat(buildIfSupported()).isNotNull()
  }

  @Test
  fun testNotBuildWithOther() {
    assumeFalse(System.getProperty("java.specification.version") == "1.8")

/** Implements the policy specified by [StartStop]. */
@SuppressSignatureCheck
internal class StartStopExtension :
  BeforeEachCallback,
  BeforeAllCallback {
  override fun beforeAll(context: ExtensionContext) {
    val store = context.getStore(Namespace.create(StartStop::class.java))

    val staticFields =
      findAnnotatedFields(
        context.requiredTestClass,

    CROSSVERSION("crossVersion", listOf("embedded", "forking"))
}


fun Test.includeSpockAnnotation(fqcn: String) {
    systemProperties.compute("include.spock.annotation") { _, oldValue ->
        if (oldValue == null) fqcn else "$oldValue,$fqcn"
    }
}


fun Test.excludeSpockAnnotation(fqcn: String) {
    systemProperties.compute("exclude.spock.annotation") { _, oldValue ->

      .certificatePinner(
        CertificatePinner
          .Builder()
          .add("publicobject.com", "sha256/Vjs8r4z+80wjNcr1YKepWQboSIRi63WsWXhIMN+eWys=")
          .build(),
      ).build()

  fun run() {
    val request =
      Request
        .Builder()
        .url("https://publicobject.com/robots.txt")
        .build()

    client.newCall(request).execute().use { response ->

  // Lazily-created.
  private var inflater: Inflater? = null
  private var inflaterSource: InflaterSource? = null

  /** Inflates [buffer] in place as described in RFC 7692 section 7.2.2. */
  @Throws(IOException::class)
  fun inflate(buffer: Buffer) {
    require(deflatedBytes.size == 0L)

    val inflater =
      this.inflater
        ?: Inflater(true).also { this.inflater = it }
    val inflaterSource =
      this.inflaterSource

import assertk.assertions.isFalse
import assertk.assertions.isTrue
import kotlin.test.Test
import kotlin.time.Duration.Companion.seconds

class CacheControlTest {
  @Test
  @Throws(Exception::class)
  fun emptyBuilderIsEmpty() {
    val cacheControl = CacheControl.Builder().build()
    assertThat(cacheControl.toString()).isEqualTo("")
    assertThat(cacheControl.noCache).isFalse()
    assertThat(cacheControl.noStore).isFalse()