private val logs = LinkedBlockingQueue<String>()

  private val handler =
    object : Handler() {
      override fun publish(logRecord: LogRecord) {
        logs += "${logRecord.level}: ${logRecord.message}"
      }

      override fun flush() {
      }

      override fun close() {
      }
    }

  private var previousLevel: Level? = null

 * limitations under the License.
 */
package okhttp3.internal.http2

import assertk.fail
import okio.BufferedSource
import okio.ByteString

internal open class BaseTestHandler : Http2Reader.Handler {
  override fun data(
    inFinished: Boolean,
    streamId: Int,
    source: BufferedSource,
    length: Int,
  ) {
    fail("")
  }

  override fun headers(
    inFinished: Boolean,

import okio.ForwardingSource
import okio.Sink
import okio.Source
import okio.buffer

/**
 * Transmits a single HTTP request and a response pair. This layers connection management and events
 * on [ExchangeCodec], which handles the actual I/O.
 */
class Exchange(
  internal val call: RealCall,
  internal val eventListener: EventListener,
  internal val finder: ExchangeFinder,
  private val codec: ExchangeCodec,
) {

    val out = Buffer()
    Http2Writer(out, true).windowUpdate(expectedStreamId, windowSizeIncrement)
    return out
  }

  private fun assertHeaderBlock(): Http2Reader.Handler {
    return object : BaseTestHandler() {
      override fun headers(
        inFinished: Boolean,
        streamId: Int,
        associatedStreamId: Int,
        headerBlock: List<Header>,
      ) {

 * one or more streams, and then released. An allocated connection won't be stolen by other calls
 * while a redirect or authorization challenge is being handled.
 *
 * When the maximum concurrent streams limit is reduced, some allocations will be rescinded.
 * Attempting to create new streams on these allocations will fail.
 *

    assertThat(request.tag<Any>()).isSameAs(objectTag)
    assertThat(request.tag(Any::class)).isSameAs(objectTag)
    assertThat(request.tag(String::class)).isSameAs(stringTag)

    // TODO check for Jvm or handle Long/long correctly
//    assertThat(request.tag(Long::class)).isSameAs(longTag)
  }

  /** Confirm that we don't accidentally share the backing map between objects. */
  @Test
  fun tagsAreImmutable() {

service.gov.scot

// Scry Security : http://www.scrysec.com
// Submitted by Shante Adam <******@****.***>
scrysec.com

// Securepoint GmbH : https://www.securepoint.de
// Submitted by Erik Anders <erik.anders@securepoint.de>
firewall-gateway.com
firewall-gateway.de
my-gateway.de
my-router.de
spdns.de
spdns.eu
firewall-gateway.net
my-firewall.org
myfirewall.org
spdns.org