// 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)

    assertThat(
      mergeAdjacentRanges(
        listOf(
          Mapping(0x0000, 0x002c, TYPE_DISALLOWED_STD3_VALID, ByteString.EMPTY),
        ),
      ),
    ).containsExactly(
      Mapping(0x0000, 0x002c, TYPE_VALID, ByteString.EMPTY),
    )
  }

  @Test fun simplifyCombinesCanonicalEquivalent() {
    assertThat(
      mergeAdjacentRanges(
        listOf(

    @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 ->

    }

    @Test
    fun `recognizes relative paths against rootDirectory`() {
        val instance = createFromPaths(listOf("test/123"))
        assertTrue(instance.isFileSystemCheckIgnoredFor(rootDir.resolve("test/123")))
    }

    @Test
    fun `recognizes multiple paths`() {
        val instance = createFromPaths(listOf("path/one", "path/two"))
        assertTrue(instance.isFileSystemCheckIgnoredFor(File("path/one")))

        // given
        mockGitOperation(listOf("git", "fetch", "origin", "master", "release"), "")
        mockGitOperation(listOf("git", "merge-base", "origin/master", "HEAD"), "master-fork-point")
        mockGitOperation(listOf("git", "merge-base", "origin/release", "HEAD"), "release-fork-point")
        mockGitOperation(listOf("git", "show", "master-fork-point:version.txt"), "5.1")

    }

    // Should not be pinned:
    certificatePinner.check("uk", listOf(certB1.certificate))
    certificatePinner.check("co.uk", listOf(certB1.certificate))
    certificatePinner.check("anotherexample.co.uk", listOf(certB1.certificate))
    certificatePinner.check("foo.anotherexample.co.uk", listOf(certB1.certificate))
  }

  @Test

            TypedProjectSchema(
                extensions = listOf(),
                conventions = listOf(),
                containerElements = listOf(),
                tasks = listOf(),
                configurations = listOf(
                    ConfigurationEntry("api"),
                    ConfigurationEntry("implementation"),
                    ConfigurationEntry("compile", listOf("api", "implementation"))
                )

    def client = new ReportDaemonStatusClient(registry, connector, idGenerator, documentationRegistry)

    def "does nothing given no daemons in registry"() {
        when:
        client.listAll()

        then:
        1 * registry.getAll() >> []
        1 * registry.getStopEvents() >> []

    val buildScanTags: List<String> = emptyList(),
    val stages: List<Stage> = listOf(
        Stage(
            StageName.QUICK_FEEDBACK_LINUX_ONLY,
            specificBuilds = listOf(
                SpecificBuild.CompileAll, SpecificBuild.SanityCheck
            ),
            functionalTests = listOf(