}

  @Test
  fun fragmentNonAscii() {
    val url = "http://host/#Σ".toHttpUrl()
    assertThat(url.toUri().toString()).isEqualTo("http://host/#Σ")
  }

  @Test
  fun fragmentPercentEncodedNonAscii() {
    val url = "http://host/#%C2%80".toHttpUrl()
    assertThat(url.toUri().toString()).isEqualTo("http://host/#%C2%80")
  }

  @Test
  fun fragmentPercentEncodedPartialCodePoint() {

        return getKtExpressionNonErrorType(subject)
    }

    private fun getKtExpressionNonErrorType(expression: KtExpression): KaType? =
        getKtExpressionType(expression)?.nonErrorTypeOrNull()

    private fun KaType.nonErrorTypeOrNull(): KaType? = takeUnless { it is KaErrorType }

    private fun PsiElement.isWhileLoopCondition() =

      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)

    fun StringBuilder.recurse(current: LanguageResult<*>, depth: Int) {
        fun indent() = "    ".repeat(depth)
        fun nextIndent() = "    ".repeat(depth + 1)
        fun appendIndented(value: Any) {
            append(indent())
            append(value)
        }
        fun appendNextIndented(value: Any) {
            append(nextIndent())
            append(value)
        }

        get() = convertLineSeparatorsToUnix(scriptFile.readText())

    private
    fun packagePrefixed(id: String) =
        packageName?.let { "$it.$id" } ?: id
}


internal
fun scriptPluginFilesOf(list: List<PrecompiledScriptPlugin>) =
    list.map { it.scriptFile }.toSet()


private
fun packageNameOf(code: String): String? =
    KotlinLexer().run {
        start(code)

    }

    @Test
    fun `can parse tokens`() {
        val parser = combinator.token(KtTokens.OPEN_QUOTE)
        assertSuccess(parser("\""))
    }

    @Test
    fun `can parse string literals`() {
        val parser = combinator.stringLiteral
        assertSuccess(
            parser("\"foo\""),
            "foo"
        )
    }

    @Test
    fun `can parse integers`() {

    )
  }

  @Test fun simplifyCanonicalizesType() {
    assertThat(
      mergeAdjacentRanges(
        listOf(
          Mapping(0x0000, 0x002c, TYPE_DISALLOWED_STD3_VALID, ByteString.EMPTY),
        ),
      ),
    ).containsExactly(
      Mapping(0x0000, 0x002c, TYPE_VALID, ByteString.EMPTY),
    )
  }

  @Test fun simplifyCombinesCanonicalEquivalent() {
    assertThat(

fun foo() {
    return/* foo@(1,1) */
}

fun bar(): String {
    return/* bar@(5,1) */""
}

fun baz(): Int {
    if (true) {
        return/* baz@(9,1) */1
    } else {
        return/* baz@(9,1) */2
    }
}

fun quux(): Int {
    while(true) {
        return/* quux@(17,1) */1
    }
    return/* quux@(17,1) */2
}

fun test() {
    run {
        return/* test@(24,1) */
    }
    fun() {

        override fun visitElement(element: FirElement) {
            element.acceptChildren(this)
        }

        override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction) = visitFunction(anonymousFunction)
        override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor) = visitFunction(propertyAccessor)

import org.jetbrains.kotlin.builtins.StandardNames
import org.jetbrains.kotlin.load.java.NULLABILITY_ANNOTATIONS

public interface KaRendererAnnotationsFilter {
    public fun filter(analysisSession: KaSession, annotation: KaAnnotation, owner: KaAnnotated): Boolean

    public infix fun and(other: KaRendererAnnotationsFilter): KaRendererAnnotationsFilter =
        KaRendererAnnotationsFilter filter@{ annotation, owner ->