*
 * ## Connection Reuse
 *
 * Each connection can carry a varying number of streams, depending on the underlying protocol being
 * used. HTTP/1.x connections can carry either zero or one streams. HTTP/2 connections can carry any
 * number of streams, dynamically configured with `SETTINGS_MAX_CONCURRENT_STREAMS`. A connection
 * currently carrying zero streams is an idle stream. We keep it alive because reusing an existing

 * Fix: Support Shoutcast HTTP responses like `ICY 200 OK`.
 * Fix: Don't unzip if there isn't a response body.
 * Fix: Don't leak gzip streams on redirects.
 * Fix: Don't do DNS lookups on invalid hosts.
 * Fix: Exhaust the underlying stream when reading gzip streams.
 * Fix: Support the `PATCH` method.
 * Fix: Support request bodies on `DELETE` method.
 * Fix: Drop the `okhttp-protocols` module.

    val bit = 1 shl ENABLE_PUSH
    return if (bit and set != 0) values[ENABLE_PUSH] == 1 else defaultValue
  }

  fun getMaxConcurrentStreams(): Int {
    val bit = 1 shl MAX_CONCURRENT_STREAMS
    return if (bit and set != 0) values[MAX_CONCURRENT_STREAMS] else Int.MAX_VALUE
  }

  fun getMaxFrameSize(defaultValue: Int): Int {
    val bit = 1 shl MAX_FRAME_SIZE
    return if (bit and set != 0) values[MAX_FRAME_SIZE] else defaultValue
  }

This is necessary for bookkeeping when creating new streams. Correct framing requires that stream IDs are sequential on the socket, so we need to bundle assigning the ID with sending the `SYN_STREAM` frame.

## Connection Pool

import assertk.assertions.isTrue
import org.junit.jupiter.api.Test

class SettingsTest {
  @Test
  fun unsetField() {
    val settings = Settings()
    assertThat(settings.isSet(Settings.MAX_CONCURRENT_STREAMS)).isFalse()
    assertThat(settings.getMaxConcurrentStreams()).isEqualTo(Int.MAX_VALUE)
  }

  @Test
  fun setFields() {
    val settings = Settings()
    settings[Settings.HEADER_TABLE_SIZE] = 8096

 */
package okhttp3.internal.http2

import okhttp3.ConnectionListener
import okhttp3.internal.http2.flowcontrol.WindowCounter

/**
 * ConnectionListener that outputs CSV for flow control of client receiving streams.
 */
class Http2FlowControlConnectionListener : ConnectionListener(), FlowControlListener {
  val start = System.currentTimeMillis()

  override fun receivingStreamWindowChanged(
    streamId: Int,

      trackFailure(e)
      throw e
    }
  }

  @Throws(IOException::class)
  fun trailers(): Headers = codec.trailers()

  @Throws(SocketException::class)
  fun newWebSocketStreams(): RealWebSocket.Streams {
    call.timeoutEarlyExit()
    return (codec.carrier as RealConnection).newWebSocketStreams(this)
  }

  fun webSocketUpgradeFailed() {
    bodyComplete(-1L, responseDone = true, requestDone = true, e = null)

    conn := manager.Connection(host).Subroute("asubroute")
	
    payload := []byte("request")
    stream, err := conn.NewStream(ctx, grid.HandlerDiskInfo, payload)
	if err != nil {
        return err
    }
    // Read results from the stream
    err = stream.Results(func(result []byte) error {
        fmt.Println("Got result", string(result))

        // Return the response for reuse

    val message = "f248cdc9c957c8cc4bcb492cc9cccf530400".decodeHex()
    assertThat(inflater.inflate(message)).isEqualTo("Hello inflation!".encodeUtf8())
  }

  /**
   * We had a bug where self-finishing inflater streams would infinite loop!
   * https://github.com/square/okhttp/issues/8078
   */
  @Test fun `inflate returns finished before bytesRead reaches input length`() {
    val inflater = MessageInflater(false)

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.idn

import kotlin.math.abs
import kotlin.streams.toList
import okio.Buffer

/** Index [table] for compactness as specified by `IdnaMappingTable`. */
fun buildIdnaMappingTableData(table: SimpleIdnaMappingTable): IdnaMappingTableData {