1D547-1D549
   1D551
   1D6A4-1D6A7
   1D7CA-1D7CD
   1D800-1FFFD
   2A6D7-2F7FF
   2FA1E-2FFFD
   30000-3FFFD
   40000-4FFFD
   50000-5FFFD
   60000-6FFFD
   70000-7FFFD
   80000-8FFFD
   90000-9FFFD
   A0000-AFFFD
   B0000-BFFFD
   C0000-CFFFD
   D0000-DFFFD
   E0000
   E0002-E001F

    val a = Settings()
    a[Settings.HEADER_TABLE_SIZE] = 10000
    a[Settings.MAX_HEADER_LIST_SIZE] = 20000
    a[Settings.INITIAL_WINDOW_SIZE] = 30000
    val b = Settings()
    b[Settings.MAX_HEADER_LIST_SIZE] = 40000
    b[Settings.INITIAL_WINDOW_SIZE] = 50000
    b[Settings.MAX_CONCURRENT_STREAMS] = 60000
    a.merge(b)
    assertThat(a.headerTableSize).isEqualTo(10000)
    assertThat(a.getMaxHeaderListSize(-1)).isEqualTo(40000)

  fun customInterval() {
    // 5 seconds starting on 1970-01-01.
    val heldCertificate =
      HeldCertificate.Builder()
        .validityInterval(5000L, 10000L)
        .build()
    val certificate = heldCertificate.certificate
    assertThat(certificate.notBefore.time).isEqualTo(5000L)
    assertThat(certificate.notAfter.time).isEqualTo(10000L)
  }

  @Test
  fun customDuration() {
    val now = System.currentTimeMillis()

  fun stringEmpty() {
    val body = body("")
    assertThat(body.string()).isEqualTo("")
  }

  @Test
  fun stringLooksLikeBomButTooShort() {
    val body = body("000048")
    assertThat(body.string()).isEqualTo("\u0000\u0000H")
  }

  @Test
  fun stringDefaultsToUtf8() {
    val body = body("68656c6c6f")
    assertThat(body.string()).isEqualTo("hello")
  }

  @Test
  fun stringExplicitCharset() {

    var i = pos
    while (i < limit) {
      val c = this[i]
      result +=
        when {
          c.isSurrogate() -> {
            val low = (if (i + 1 < limit) this[i + 1] else '\u0000')
            if (c.isLowSurrogate() || !low.isLowSurrogate()) {
              '?'.code
            } else {
              i++
              0x010000 + (c.code and 0x03ff shl 10 or (low.code and 0x03ff))

      "Invalid URL host: \"[0000:0000:0000:0000:0000:0000:0000:0001:]\"",
    )
    assertInvalid(
      "http://[0000:0000:0000:0000:0000:0000:0000:0001::]",
      "Invalid URL host: \"[0000:0000:0000:0000:0000:0000:0000:0001::]\"",
    )
    assertInvalid(
      "http://[0000:0000:0000:0000:0000:0000:0000:0001:::]",
      "Invalid URL host: \"[0000:0000:0000:0000:0000:0000:0000:0001:::]\"",

    }
  }

  @Test
  fun urlHostWithNul() {
    assertFailsWith<IllegalArgumentException> {
      "http://host\u0000/".toHttpUrl()
    }
  }

  @Test
  fun urlRedirectToHostWithNul() {
    val redirectUrl = "http://host\u0000/"
    server.enqueue(
      MockResponse.Builder()
        .code(302)
        .addHeaderLenient("Location", redirectUrl)
        .build(),

distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-all.zip
networkTimeout=10000
validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME

  @Test
  fun testPublicSuffixes() {
    platform.assumeNotGraalVMImage()

    val metadata = FileSystem.RESOURCES.metadata(PublicSuffixDatabase.PUBLIC_SUFFIX_RESOURCE)
    assertThat(metadata.size!!).isGreaterThan(30000)
  }

class TaskRunner(
  val backend: Backend,
  internal val logger: Logger = TaskRunner.logger,
) {
  val lock: ReentrantLock = ReentrantLock()
  val condition: Condition = lock.newCondition()

  private var nextQueueName = 10000
  private var coordinatorWaiting = false
  private var coordinatorWakeUpAt = 0L

  /**
   * When we need a new thread to run tasks, we call [Backend.execute]. A few microseconds later we