}
  }

  private fun greaterThan(value: Long): Matcher<Long?> {
    return object : BaseMatcher<Long?>() {
      override fun describeTo(description: Description?) {
        description!!.appendText("> $value")
      }

      override fun matches(o: Any?): Boolean {
        return (o as Long?)!! > value
      }
    }
  }

  private fun matchesProtocol(protocol: Protocol?): Matcher<Response?> {

     * cache-control headers.
     */
    open fun cacheControl(cacheControl: CacheControl): Builder = commonCacheControl(cacheControl)

    open fun get(): Builder = commonGet()

    open fun head(): Builder = commonHead()

    open fun post(body: RequestBody): Builder = commonPost(body)

    @JvmOverloads
    open fun delete(body: RequestBody? = commonEmptyRequestBody): Builder = commonDelete(body)

internal class UnreadableResponseBody(
  private val mediaType: MediaType?,
  private val contentLength: Long,
) : ResponseBody(), Source {
  override fun contentType() = mediaType

  override fun contentLength() = contentLength

  override fun source() = buffer()

  override fun read(
    sink: Buffer,
    byteCount: Long,
  ): Long {
    throw IllegalStateException(
      """

    call: Call,
    connection: Connection,
  ) = logEvent(ConnectionReleased(System.nanoTime(), call, connection))

  override fun callStart(call: Call) = logEvent(CallStart(System.nanoTime(), call))

  override fun requestHeadersStart(call: Call) = logEvent(RequestHeadersStart(System.nanoTime(), call))

  override fun requestHeadersEnd(
    call: Call,
    request: Request,

  private var server: MockWebServer? = null

  @BeforeEach fun setUp(server: MockWebServer?) {
    this.server = server
  }

  @AfterEach fun tearDown() {
    ProxySelector.setDefault(DEFAULT_PROXY_SELECTOR)
    CookieManager.setDefault(DEFAULT_COOKIE_HANDLER)
    ResponseCache.setDefault(DEFAULT_RESPONSE_CACHE)
  }

  @Test fun durationDefaults() {
    val client = clientTestRule.newClient()

      isClient = true,
      source = data,
      frameCallback = callback.asFrameCallback(),
      perMessageDeflate = true,
      noContextTakeover = false,
    )

  @AfterEach fun tearDown() {
    callback.assertExhausted()
  }

  @Test fun controlFramesMustBeFinal() {
    data.write("0a00".decodeHex()) // Empty pong.
    assertFailsWith<ProtocolException> {
      clientReader.processNextFrame()
    }.also { expected ->

import org.junit.jupiter.api.Test

class CertificatePinnerTest {
  @Test
  fun malformedPin() {
    val builder = CertificatePinner.Builder()
    assertFailsWith<IllegalArgumentException> {
      builder.add("example.com", "md5/DmxUShsZuNiqPQsX2Oi9uv2sCnw=")
    }
  }

  @Test
  fun malformedBase64() {
    val builder = CertificatePinner.Builder()
    assertFailsWith<IllegalArgumentException> {

    val arch: Arch
    val withoutDependencies: Boolean

    fun asConfigurationId(model: CIBuildModel, bucket: String): String
    fun channel(): String
}

interface PerformanceTestProjectSpec {
    val os: Os
    val type: PerformanceTestType
    val failsStage: Boolean

    fun asConfigurationId(model: CIBuildModel): String
    fun asName(): String
    fun channel(): String
}

data class PerformanceTestPartialTrigger(

          newUnknownLengthSource()
        }
      }
    }
  }

  override fun trailers(): Headers {
    check(state == STATE_CLOSED) { "too early; can't read the trailers yet" }
    return trailers ?: EMPTY_HEADERS
  }

  override fun flushRequest() {
    sink.flush()
  }

  override fun finishRequest() {
    sink.flush()
  }

      this.trailersFn = response.trailersFn
    }

    open fun request(request: Request) = commonRequest(request)

    open fun protocol(protocol: Protocol) = commonProtocol(protocol)

    open fun code(code: Int) = commonCode(code)

    open fun message(message: String) = commonMessage(message)

    open fun handshake(handshake: Handshake?) =
      apply {
        this.handshake = handshake