val a = listOf("a", "b", "c")
        val b = listOf("a", "b", "c")

        assertThat(
            commonPrefixOf(listOf(a, b)),
            equalTo(listOf("a", "b", "c"))
        )
    }

    @Test
    fun `common is empty for different prefix`() {

        val a = listOf("0", "a", "b", "c")
        val b = listOf("1", "a", "b", "c")

        assertThat(
            commonPrefixOf(listOf(a, b)),

            importsToAdd = listOf(
                "org.jetbrains.kotlin.psi.KtExpression",
                "org.jetbrains.kotlin.psi"
            )
        ),
        KtSourceElement::class to HLFunctionCallConversion(
            "({0} as? KtPsiSourceElement)?.psi",
            PsiElement::class.createType(nullable = true),
            importsToAdd = listOf(
                "org.jetbrains.kotlin.psi",

        globalExtension.taskPathToReports = taskPathToReports
    }
}

fun Task.customReports(): List<File> = when (this) {
    is ValidatePlugins -> listOf(outputFile.get().asFile)
    is FindBrokenInternalLinks -> listOf(reportFile.get().asFile)
    is DistributionTest -> listOf(
        gradleInstallationForTest.gradleUserHomeDir.dir("test-kit-daemon").get().asFile,

        assertThat(
            defaultPackageTypesIn(listOf("java.util.Map<Key, Value>")),
            equalTo(listOf("Key", "Value"))
        )
    }

    @Test
    fun `#defaultPackageTypesIn (duplicate types)`() {

        assertThat(
            defaultPackageTypesIn(listOf("java.util.Map<Value, Value>")),
            equalTo(listOf("Value"))
        )
    }

    // Define toolchain-specific compiler options
    compilerArgs.addAll(toolChain.map { toolChain ->
        when (toolChain) {
            is Gcc, is Clang -> listOf("-O2", "-fno-access-control")
            is VisualCpp -> listOf("/Zi")
            else -> listOf()
        }
    })
}
// end::cpp-compiler-options-all-variants[]

// tag::cpp-compiler-options-per-variants[]
application {

                    KaClassKind.CLASS -> listOf(KtTokens.CLASS_KEYWORD)
                    KaClassKind.ENUM_CLASS -> listOf(KtTokens.ENUM_KEYWORD, KtTokens.CLASS_KEYWORD)
                    KaClassKind.ANNOTATION_CLASS -> listOf(KtTokens.ANNOTATION_KEYWORD, KtTokens.CLASS_KEYWORD)
                    KaClassKind.OBJECT -> listOf(KtTokens.OBJECT_KEYWORD)
                    KaClassKind.COMPANION_OBJECT -> listOf(KtTokens.COMPANION_KEYWORD, KtTokens.OBJECT_KEYWORD)

  companion object {
    @Suppress("unused")
    @JvmStatic
    fun connectionTypes(): List<SocketMode> =
      listOf(CONSCRYPT, JSSE).flatMap { provider ->
        listOf(HTTP_1_1, HTTP_2).flatMap { protocol ->
          listOf(TLS_1_3, TLS_1_2).flatMap { tlsVersion ->
            listOf(Channel, Standard).flatMap { socketMode ->
              listOf(DISABLED, STANDARD).map { tlsExtensionMode ->

    val stageName: StageName,
    val specificBuilds: List<SpecificBuild> = emptyList(),
    val functionalTests: List<TestCoverage> = emptyList(),
    val docsTests: List<DocsTestCoverage> = emptyList(),
    val performanceTests: List<PerformanceTestCoverage> = emptyList(),
    val performanceTestPartialTriggers: List<PerformanceTestPartialTrigger> = emptyList(),
    val flameGraphs: List<FlameGraphGeneration> = emptyList(),

            "My",
            listOf("My.class", "MyKt.class")
        )

        assertClassFilePathCandidatesFor(
            "foo.My",
            listOf("foo/My.class", "foo/MyKt.class", "foo${'$'}My.class", "foo${'$'}MyKt.class")
        )

        assertClassFilePathCandidatesFor(
            "foo.My.Nested",
            listOf(
                "foo/My/Nested.class", "foo/My/NestedKt.class",

            $repositoriesBlock

            tasks {
                register("assertions") {
                    doLast {
                        val requiredLibs = listOf("kotlin-stdlib-$embeddedKotlinVersion.jar", "kotlin-reflect-$embeddedKotlinVersion.jar")
                        listOf("compileOnlyClasspath", "testRuntimeClasspath").forEach { configuration ->