*/
@Suppress("DEPRECATION")
class HeldCertificate(
  @get:JvmName("keyPair") val keyPair: KeyPair,
  @get:JvmName("certificate") val certificate: X509Certificate,
) {
  @JvmName("-deprecated_certificate")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "certificate"),
    level = DeprecationLevel.ERROR,
  )

  @Test fun builderSameSiteNoneDoesNotRequireSecure() {
    val cookieBuilder =
      Cookie
        .Builder()
        .name("a")
        .value("b")
        .domain("example.com")
        .sameSite("None")

    val cookie = cookieBuilder.build()
    assertThat(cookie.sameSite).isEqualTo("None")
  }

  @Test fun equalsAndHashCode() {
    val cookieStrings =
      Arrays.asList(

 */
class TaskQueue internal constructor(
  internal val taskRunner: TaskRunner,
  internal val name: String,
) {
  internal var shutdown = false

  /** This queue's currently-executing task, or null if none is currently executing. */
  internal var activeTask: Task? = null

  /** Scheduled tasks ordered by [Task.nextExecuteNanoTime]. */
  internal val futureTasks = mutableListOf<Task>()

      if (isWriter) {
        writerToClose?.closeQuietly()
      }
    }
  }

  internal class Message(
    val formatOpcode: Int,
    val data: ByteString,
  )

  internal class Close(
    val code: Int,
    val reason: ByteString?,
    val cancelAfterCloseMillis: Long,
  )

  private inner class WriterTask : Task("$name writer") {
    override fun runOnce(): Long {
      try {

 * of its component streams are closed. This class takes advantage of that.
 */
internal class MockWebServerSocket(
  val javaNetSocket: Socket,
) : Closeable,
  BufferedSocket {
  private val delegate = javaNetSocket.asOkioSocket()
  private val closedLatch = CountDownLatch(2)

  override val source: BufferedSource =
    object : ForwardingSource(delegate.source) {
      private var closed = false

      }
      node = child
    }

    val shift = 8 - accumulatorBitCount
    val start = (code shl shift) and 0xff
    val end = 1 shl shift
    node.children!!.fill(terminal, start, start + end)
  }

  private class Node {
    /** Null if terminal. */
    val children: Array<Node?>?

    /** Terminal nodes have a symbol. */
    val symbol: Int

   */
  public val target: String,
  /** A string like `HTTP/1.1` or `HTTP/2`. */
  public val version: String,
  /** The request URL built using the request line, headers, and local host name. */
  public val url: HttpUrl,
  /** All headers. */
  public val headers: Headers,
  /** The body of this request, or null if it has none. This may be truncated. */
  public val body: ByteString?,

    // We use UTF-8 in the list so we need to convert to Unicode.
    val unicodeDomain = IDN.toUnicode(domain)
    val domainLabels = splitDomain(unicodeDomain)

    val rule = findMatchingRule(domainLabels)
    if (domainLabels.size == rule.size && rule[0][0] != EXCEPTION_MARKER) {
      return null // The domain is a public suffix.
    }

    val firstLabelOffset =
      if (rule[0][0] == EXCEPTION_MARKER) {

    val response = call.execute()
    val cancelLatch = cancelLater(call, 500)
    val responseBody = response.body.byteStream()
    val buffer = ByteArray(1024)
    assertFailsWith<IOException> {
      while (responseBody.read(buffer) != -1) {
      }
    }.also { expected ->
      assertEquals(cancelMode == INTERRUPT, Thread.interrupted())
    }
    responseBody.close()

     4. Use dogfood-second to run a Gradle build which runs tests.

     */
        val dogfoodTimestamp1 = "19800101010101+0000"
        val dogfoodTimestamp2 = "19800202020202+0000"
        val buildScanTagForType = buildScanTagParam("Gradleception")
        val buildScanTagForGroovyMajor = buildScanTagParam("Groovy$bundleGroovyMajor")
        val buildScanTags =