FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override]
        overridden:
          public open fun hashCode (): kotlin.Int declared in kotlin.Any
        $this: VALUE_PARAMETER name:<this> type:kotlin.Any
      FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override]

			fun.f.Blocks[0], fun.values["A1"].ID, fun.values["A1carry"].ID, fun.values["A1Carryvalue"].ID,
			fun.values["A2"].ID, fun.values["A2carry"].ID, fun.values["A2Carryvalue"].ID)
	}

        }
      }
    }

    override fun put(element: T) {
      taskRunner.lock.withLock {
        delegate.put(element)
        editCount++
      }
    }

    override fun iterator() = error("unsupported")

    override fun offer(e: T) = error("unsupported")

    override fun peek(): T = error("unsupported")

    override fun offer(
      element: T,
      timeout: Long,

    protected
    fun jarClassPathWith(vararg classes: KClass<*>): ClassPath =
        jarClassPathWith("cp.jar", *classes)

    protected
    fun jarClassPathWith(path: String, vararg classes: KClass<*>): ClassPath = classPathOf(
        file(path).also { jar ->
            zipTo(jar, classEntriesFor(classes))
        }
    )

    protected

    override fun visitSource(file: String?, debug: String?) = Unit
    override fun visitOuterClass(owner: String?, name: String?, desc: String?) = Unit
    override fun visitTypeAnnotation(typeRef: Int, typePath: TypePath?, desc: String?, visible: Boolean): AnnotationVisitor? = null
    override fun visitAttribute(attr: Attribute?) = Unit

class IntegrationTestFixturesRule : AbstractAstVisitorRule() {
    override fun getName(): String = "IntegrationTestFixtures"

    override fun getPriority(): Int = 1

    override fun setPriority(priority: Int) {
        throw UnsupportedOperationException()
    }

    override fun setName(name: String?) {
        throw UnsupportedOperationException()
    }

                obj: GET_VAR '<this>: <root>.Foo declared in <root>.Foo.test' type=<root>.Foo origin=null
          CALL 'local final fun call (): kotlin.Unit declared in <root>.Foo.test' type=kotlin.Unit origin=null
    FUN name:call visibility:local modality:FINAL <> () returnType:kotlin.Unit

import org.junit.jupiter.api.Test

class WebSocketExtensionsTest {
  @Test
  fun emptyHeader() {
    assertThat(parse("")).isEqualTo(WebSocketExtensions())
  }

  @Test
  fun noExtensionHeader() {
    assertThat(WebSocketExtensions.parse(headersOf()))
      .isEqualTo(WebSocketExtensions())
  }

  @Test
  fun emptyExtension() {
    assertThat(parse(", permessage-deflate"))

import okio.BufferedSink
import okio.ByteString

fun ByteArray.commonToRequestBody(
  contentType: MediaType?,
  offset: Int,
  byteCount: Int,
): RequestBody {
  checkOffsetAndCount(size.toLong(), offset.toLong(), byteCount.toLong())
  return object : RequestBody() {
    override fun contentType() = contentType

    override fun contentLength() = byteCount.toLong()

    override fun writeTo(sink: BufferedSink) {

        }

        fun toInt(): Int = sequence().count() - 1

        object Z : Peano() {
            override fun toString() = "Z"
        }

        data class S(val n: Peano) : Peano() {
            override fun toString() = "S($n)"
        }

        private
        fun sequence() = generateSequence(this) { previous ->
            when (previous) {
                is Z -> null