buffer.writeUtf8(
      """
      |    180C; ; Map to nothing
      |    0041; 0061; Case map
      |    0390; 03B9 0308 0301; Case map
      |
      """.trimMargin(),
    )

    val mappings = buffer.readCodePointMappings()
    assertEquals(
      mapOf(
        // Map to nothing.
        0x180c to "",
        // Case map.
        'A'.code to "a",
        // Case map.
        'ΐ'.code to "\u03B9\u0308\u0301",
      ),

            firDiagnostic.c.map { coneKotlinType ->
                firSymbolBuilder.typeBuilder.buildKtType(coneKotlinType)
            },
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.AMBIGUOUS_SUPER) { firDiagnostic ->
        AmbiguousSuperImpl(
            firDiagnostic.a.map { coneKotlinType ->

    }

    fun getAllConverters(conversionForCollectionValues: HLParameterConversion): Map<KClass<*>, HLParameterConversion> {
        return buildMap {
            putAll(typeMapping)
            put(
                Map::class,
                HLMapParameterConversion(
                    "key",
                    "value",

    listOf("7.3", "7.6"), // 7.3 <=version < 7.6
    listOf("7.6", "8.3"), // 7.6 <=version < 8.3
    listOf("8.3", "99.0") // 8.3 <=version < 99.0
)

typealias BuildProjectToSubprojectTestClassTimes = Map<String, Map<String, List<TestClassTime>>>

interface FunctionalTestBucketProvider {
    fun createFunctionalTestsFor(stage: Stage, testCoverage: TestCoverage): List<FunctionalTest>
}

        }

        fun assertHasErrors(vararg errors: String) {
            assertThat("Has errors", richReport.errors.map { it.message }, CoreMatchers.equalTo(errors.toList()))
        }

        fun assertHasWarnings(vararg warnings: String) {
            assertThat("Has warnings", richReport.warnings.map { it.message }, CoreMatchers.equalTo(warnings.toList()))
        }

    classpath.from(tasks.named<GroovyCompile>("compileGroovy"))
    destinationFile = project.layout.buildDirectory.file(
        moduleIdentity.baseName.map { "generated-resources/$it-parameter-names/$it-parameter-names.properties" }
    )
}

main.output.dir(
    parameterNamesIndex.map { it.destinationFile.get().asFile.parentFile }

        return element.getDiagnostics(firResolveSession, filter.asLLFilter()).map { it.asKtDiagnostic() }
    }

    override fun collectDiagnosticsForFile(ktFile: KtFile, filter: KtDiagnosticCheckerFilter): Collection<KtDiagnosticWithPsi<*>> =
        ktFile.collectDiagnosticsForFile(firResolveSession, filter.asLLFilter()).map { it.asKtDiagnostic() }


    private fun KtDiagnosticCheckerFilter.asLLFilter() = when (this) {

    } catch (uhe: UnknownHostException) {
      // expected
    }

    val logs = ShadowLog.getLogsForTag("testHttpLoggingInterceptor")
    assertThat(logs.map { it.type }).containsOnly(Log.INFO)
    assertThat(logs.map { it.msg }).containsExactly(
      "--> GET http://google.com/robots.txt",
      "<-- HTTP FAILED: java.net.UnknownHostException: shortcircuit",
    )

                    KtClassTypeQualifier.KtResolvedClassTypeQualifier(
                        innerType.classDescriptor.toKtClassSymbol(analysisContext),
                        innerType.arguments.map { it.toKtTypeProjection(analysisContext) },
                        token
                    )
                }

            }
        }

    override val classId: ClassId

                    overriddenElement,
                    callableSymbol.analysisSession.useSiteSession
                )
            }
        }

        return overriddenElement.map { analysisSession.firSymbolBuilder.callableBuilder.buildCallableSymbol(it) }
    }

    override fun <T : KtSymbol> getDirectlyOverriddenSymbols(callableSymbol: T): List<KtCallableSymbol> {