fun hostnameMultipleCharacterMapping() {
    // Map the single character telephone symbol (℡) to the string "tel".
    assertThat(parse("http://\u2121").host).isEqualTo("tel")
  }

  @Test
  fun hostnameMappingLastMappedCodePoint() {
    assertThat(parse("http://\uD87E\uDE1D").host).isEqualTo("xn--pu5l")
  }

  // The java.net.IDN implementation doesn't ignore characters that it should.
  @Ignore
  @Test

    override fun doResolveExpression(context: AnalysisContext, expr: Expr): ObjectOrigin? =
        expressionResolver.doResolveExpression(context, expr)

    override fun analyzeStatementsInProgramOrder(context: AnalysisContext, elements: List<DataStatement>) {
        codeAnalyzer.analyzeStatementsInProgramOrder(context, elements)
    }

    override fun doResolvePropertyAccessToObjectOrigin(

internal
fun LighterASTNode.sourceData(sourceIdentifier: SourceIdentifier, sourceCode: String, sourceOffset: Int) =
    LightTreeSourceData(sourceIdentifier, sourceCode, sourceOffset, this.range())


private
fun LighterASTNode.print(indent: String) {
    println("$indent$tokenType (${range()}): ${content()}")
}


internal
fun LighterASTNode.range() = startOffset.until(endOffset)


private

     * Constant value represented as Kotlin code. E.g: `1`, `2f, `3u` `null`, `"str"`
     */
    public abstract fun renderAsKotlinConstant(): String

    public class KaNullConstantValue(override val sourcePsi: KtElement?) : KaConstantValue(ConstantValueKind.Null) {
        override val value: Nothing? get() = null
        override fun renderAsKotlinConstant(): String = "null"
    }

    public class KaBooleanConstantValue(

fun <S> foo1(t: Int): Int fromClass Y
  S from /Y.foo1
  t: Int from /Y.foo1

fun <Q> foo2(t: Int) fromClass Y
  Q from /Y.foo2
  t: Int from /Y.foo2

fun <U> foo3() fromClass X
  U from /X.foo3

fun equals(other: Any?): Boolean fromClass kotlin/Any
  other: Any? from kotlin/Any.equals

fun hashCode(): Int fromClass kotlin/Any

fun toString(): String fromClass kotlin/Any

  }

  @Test
  fun serverClosesSocket() {
    testServerClosesOutput(DisconnectAtEnd)
  }

  @Test
  fun serverShutdownInput() {
    testServerClosesOutput(ShutdownInputAtEnd)
  }

  @Test
  fun serverShutdownOutput() {
    testServerClosesOutput(ShutdownOutputAtEnd)
  }

  @Test
  fun invalidHost() {

    }

    fun compilationClassPathOf(scope: ClassLoaderScope): ClassPath =
        cachedScopeCompilationClassPath.computeIfAbsent(scope, ::computeCompilationClassPath)

    private
    fun computeCompilationClassPath(scope: ClassLoaderScope): ClassPath {
        return gradleKotlinDsl + exportClassPathFromHierarchyOf(scope)
    }

    internal

sealed class HLParameterConversion {
    abstract fun convertExpression(expression: String, context: ConversionContext): String
    abstract fun convertType(type: KType): KType
    open val importsToAdd: List<String> get() = emptyList()
}

object HLIdParameterConversion : HLParameterConversion() {
    override fun convertExpression(expression: String, context: ConversionContext) = expression
    override fun convertType(type: KType): KType = type
}

                classBody()
            }
        )
    }

    private
    fun writeFile(relativePath: String, bytes: ByteArray) {
        outputFile(relativePath).writeBytes(bytes)
    }

    private
    fun outputFile(relativePath: String) =
        outputDir.resolve(relativePath)

    private
    fun compileStage1(
        source: ProgramSource,
        scriptDefinition: ScriptDefinition,

        get() = tempFolder.testDirectory

    fun withFolders(folders: FoldersDslExpression) =
        root.withFolders(folders)

    fun folder(path: String): File =
        existing(path).apply {
            assert(isDirectory)
        }

    fun file(path: String): File =
        existing(path).apply {
            assert(isFile)
        }

    private
    fun existing(path: String): File =