}

  /**
   * A callback to be invoked each time the dispatcher becomes idle (when the number of running
   * calls returns to zero).
   *
   * Note: The time at which a [call][Call] is considered idle is different depending on whether it
   * was run [asynchronously][Call.enqueue] or [synchronously][Call.execute]. Asynchronous calls
   * become idle after the [onResponse][Callback.onResponse] or [onFailure][Callback.onFailure]

            year = matcher.group(1).toInt()
          }
        }

        pos = dateCharacterOffset(s, end + 1, limit, false)
      }

      // Convert two-digit years into four-digit years. 99 becomes 1999, 15 becomes 2015.
      if (year in 70..99) year += 1900
      if (year in 0..69) year += 2000

      // If any partial is omitted or out of range, return -1. The date is impossible. Note that leap

      payload.writeByte('0'.code)
    }
    serverWriter.writeMessageFrame(OPCODE_BINARY, payload.snapshot())

    // Write directly to the unbuffered sink. This ensures it will become single frame.
    assertData("827e") // 'e' == 4-byte follow-up length.
    assertData(format("%04X", payload.completeSegmentByteCount()))
    assertData(payload.readByteString())
  }

    // (excluding the characters covered above).
    if (" #%/:?@[\\]".indexOf(c) != -1) {
      return true
    }
  }
  return false
}

/** Decodes an IPv6 address like 1111:2222:3333:4444:5555:6666:7777:8888 or ::1. */
internal fun decodeIpv6(
  input: String,
  pos: Int,
  limit: Int,
): ByteArray? {
  val address = ByteArray(16)
  var b = 0

  private fun testConnectViaProxy(proxyConfig: ProxyConfig) {
    server.enqueue(
      MockResponse(body = "this response comes via a proxy"),
    )
    val url = "http://android.com/foo".toHttpUrl()
    val response = proxyConfig.connect(server, client, url).execute()
    assertContent("this response comes via a proxy", response)
    val request = server.takeRequest()
    assertThat(request.requestLine).isEqualTo(

   * they will be absent (unless they were already returned).
   *
   * If there are I/O problems during iteration, this iterator fails silently. For example, if the
   * hosting filesystem becomes unreachable, the iterator will omit elements rather than throwing
   * exceptions.
   *
   * **The caller must [close][Snapshot.close]** each snapshot returned by [Iterator.next]. Failing
   * to do so leaks open files!

            value: Long,
          ) {
            val string = formatGeneralizedTime(value)
            return writer.writeUtf8(string)
          }
        },
    )

  /** Decodes any value without interpretation as [AnyValue]. */
  val ANY_VALUE =
    object : DerAdapter<AnyValue> {
      override fun matches(header: DerHeader): Boolean = true

    bytesIn.writeByte(0x40) // Literal indexed
    bytesIn.writeByte(0x88) // Literal name Huffman encoded 8 bytes
    // decodes to custom-key which is length 10
    bytesIn.write("25a849e95ba97d7f".decodeHex())
    bytesIn.writeByte(0x89) // Literal value Huffman encoded 9 bytes
    // decodes to custom-value which is length 12
    bytesIn.write("25a849e95bb8e8b4bf".decodeHex())
  }

          if (minDelayNanos < coordinatorWakeUpAt - now) {
            backend.coordinatorNotify(this@TaskRunner)
          }
          return null
        }

        // No other thread is coordinating. Become the coordinator!
        else -> {
          coordinatorWaiting = true
          coordinatorWakeUpAt = now + minDelayNanos
          try {
            backend.coordinatorWait(this@TaskRunner, minDelayNanos)

    above. See [Jetty's overview][jetty_8_252] of the API change and its consequences.


## Version 3.12.10

_2020-02-29_

 *  Fix: Don't crash on Android 4.1 when detecting methods that became restricted in Android 11.
    Supporting a full decade of Android releases on our 3.12.x branch is tricky!


## Version 3.12.9

_2020-02-24_