}

  @Test fun `encode primitive string`() {
    val buffer = Buffer()
    val derWriter = DerWriter(buffer)

    derWriter.write("test", tagClass = DerHeader.TAG_CLASS_UNIVERSAL, tag = 26L) {
      derWriter.writeOctetString("Jones".encodeUtf8())
    }

    assertThat(buffer.readByteString()).isEqualTo("1A054A6F6E6573".decodeHex())
  }

  @Test fun `decode implicit prefixed type`() {

  }

  private fun nextEvent(): Any {
    return events.poll(10, TimeUnit.SECONDS)
      ?: throw AssertionError("Timed out waiting for event.")
  }

  fun assertTextMessage(payload: String?) {
    assertThat(nextEvent()).isEqualTo(Message(string = payload))
  }

  fun assertBinaryMessage(payload: ByteString?) {
    assertThat(nextEvent()).isEqualTo(Message(payload))
  }

  fun assertPing(payload: ByteString) {

internal interface KaFirDiagnosticCreator

internal fun interface KaFirDiagnostic0Creator : KaFirDiagnosticCreator {
    fun KaFirSession.create(diagnostic: KtSimpleDiagnostic): KaFirDiagnostic<*>
}

internal fun interface KaFirDiagnostic1Creator<A> : KaFirDiagnosticCreator {
    fun KaFirSession.create(diagnostic: KtDiagnosticWithParameters1<A>): KaFirDiagnostic<*>
}

internal fun interface KaFirDiagnostic2Creator<A, B> : KaFirDiagnosticCreator {

    public abstract fun getTypeAliasSymbol(psi: KtTypeAlias): KaTypeAliasSymbol
    public abstract fun getEnumEntrySymbol(psi: KtEnumEntry): KaEnumEntrySymbol
    public abstract fun getAnonymousFunctionSymbol(psi: KtNamedFunction): KaAnonymousFunctionSymbol
    public abstract fun getAnonymousFunctionSymbol(psi: KtFunctionLiteral): KaAnonymousFunctionSymbol

) : MessageCollector {

    val errors = arrayListOf<ScriptCompilationError>()

    override fun hasErrors() = errors.isNotEmpty()

    override fun clear() = errors.clear()

    override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageSourceLocation?) {

        fun msg() =
            location?.run {
                path.let(pathTranslation).let { path ->

		return nil
	}

	fun := astutil.Unparen(call.Args[1])
	if lit, ok := fun.(*ast.FuncLit); ok { // function lit?
		return &asyncCall{region: lit, async: call, scope: lit, fun: fun}
	}

	if id := funcIdent(fun); id != nil {
		if lit := funcLitInScope(id); lit != nil { // function lit in variable?
			return &asyncCall{region: lit, async: call, scope: lit, fun: fun}
		}
	}

}

private fun convertArgument(argument: FirEnumEntrySymbol, firSymbolBuilder: KaSymbolByFirBuilder): Any? {
    return firSymbolBuilder.buildSymbol(argument)
}

private fun convertArgument(argument: FirRegularClassSymbol, firSymbolBuilder: KaSymbolByFirBuilder): Any? {
    return firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(argument)
}

    override fun getPosition() = position
}


internal
data class DefaultEditorPosition(
    private val line: Int,
    private val column: Int = 0
) : EditorPosition, Serializable {

    override fun getLine() = line

    override fun getColumn() = column
}


internal
fun File.readLinesRange() =
    countLines().let { count ->
        if (count == 0L) 0..0L

  override fun callEnd(call: Call) {
    logWithTime("callEnd")

    delegate.callEnd(call)
  }

  override fun callFailed(
    call: Call,
    ioe: IOException,
  ) {
    logWithTime("callFailed: $ioe")

    delegate.callFailed(call, ioe)
  }

  override fun canceled(call: Call) {
    logWithTime("canceled")

    delegate.canceled(call)
  }

  override fun satisfactionFailure(

    delegate!!.invalidate()
  }

  override fun isValid(): Boolean {
    return delegate!!.isValid
  }

  override fun putValue(
    s: String,
    o: Any,
  ) {
    delegate!!.putValue(s, o)
  }

  override fun getValue(s: String): Any {
    return delegate!!.getValue(s)
  }

  override fun removeValue(s: String) {
    delegate!!.removeValue(s)
  }