*  Fix: Don't crash when the URL hostname contains an underscore on Android.
 *  Fix: Change HTTP/2 to use a daemon thread for its socket reader. If you've ever seen a command
    line application hang after all of the work is done, it may be due to a non-daemon thread like
    this one.
 *  New: Include suppressed exceptions when all routes to a target service fail.


## Version 4.4.1

    assertThat(nextEvent()).isEqualTo(Pong(payload))
  }

  fun assertClosing(
    code: Int,
    reason: String,
  ) {
    assertThat(nextEvent()).isEqualTo(Closing(code, reason))
  }

  fun assertClosed(
    code: Int,
    reason: String,
  ) {
    assertThat(nextEvent()).isEqualTo(Closed(code, reason))
  }

  fun assertExhausted() {
    assertThat(events).isEmpty()
  }

      }
      set(value) {
        val reason =
          when (value) {
            in 100..199 -> "Informational"
            in 200..299 -> "OK"
            in 300..399 -> "Redirection"
            in 400..499 -> "Client Error"
            in 500..599 -> "Server Error"
            else -> "Mock Response"
          }
        status = "HTTP/1.1 $value $reason"
      }

        .addInterceptor(applicationInterceptor)
        .build()
    try {
      client.newCall(request().build()).execute()
      fail<Any>()
    } catch (expected: UnknownHostException) {
    }
    applicationLogs
      .assertLogEqual("--> GET $url")
      .assertLogEqual("<-- HTTP FAILED: java.net.UnknownHostException: reason")
      .assertNoMoreLogs()
  }

import okhttp3.internal.threadFactory

/**
 * A set of worker threads that are shared among a set of task queues.
 *
 * Use [INSTANCE] for a task runner that uses daemon threads. There is not currently a shared
 * instance for non-daemon threads.
 *
 * The task runner is also responsible for releasing held threads when the library is unloaded.
 * This is for the benefit of container environments that implement code unloading.

    val server = serverListener.assertOpen()
    clientListener.assertOpen()
    val reason = repeat('X', 124)
    assertFailsWith<IllegalArgumentException> {
      webSocket.close(1000, reason)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("reason.size() > 123: $reason")
    }
    webSocket.close(1000, null)
    serverListener.assertClosing(1000, "")
    server.close(1000, null)

on:
  push:
    branches:
      - master
  pull_request:
    types: [opened, labeled, unlabeled, synchronize]

permissions:
  contents: read

env:
  GRADLE_OPTS: "-Dorg.gradle.jvmargs=-Xmx4g -Dorg.gradle.daemon=false -Dkotlin.incremental=false"

jobs:
  test_docs:
    permissions:
      checks: write # for actions/upload-artifact
    runs-on: ubuntu-latest

@JvmField
internal val UTC: TimeZone = TimeZone.getTimeZone("GMT")!!

internal fun threadFactory(
  name: String,
  daemon: Boolean,
): ThreadFactory =
  ThreadFactory { runnable ->
    Thread(runnable, name).apply {
      isDaemon = daemon
    }
  }

internal fun HttpUrl.toHostHeader(includeDefaultPort: Boolean = false): String {
  val host =
    if (":" in host) {
      "[$host]"

  }

  @Test fun closeCallsCallback() {
    data.write("880703e848656c6c6f".decodeHex()) // Close with code and reason
    clientReader.processNextFrame()
    callback.assertClosing(1000, "Hello")
  }

  @Test fun closeIncompleteCallsCallback() {
    data.write("880703e948656c6c6f".decodeHex()) // Close with code and reason
    data.close()
    clientReader.processNextFrame()
    callback.assertClosing(1001, "Hello")
  }

   * if no streams were processed.
   *
   * @param lastGoodStreamId the last stream ID processed, or zero if no streams were processed.
   * @param errorCode reason for closing the connection.
   * @param debugData only valid for HTTP/2; opaque debug data to send.
   */
  @Throws(IOException::class)
  fun goAway(
    lastGoodStreamId: Int,
    errorCode: ErrorCode,