kotlin-fork/kotlin-native/backend.native/tests/build.gradle

/*
 * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
 * that can be found in the LICENSE file.
 */

import org.jetbrains.kotlin.*
import org.jetbrains.kotlin.gradle.plugin.tasks.KonanCompileNativeBinary
import org.jetbrains.kotlin.konan.target.Architecture
import org.jetbrains.kotlin.konan.target.Family
import org.jetbrains.kotlin.konan.target.HostManager
import org.jetbrains.kotlin.konan.target.KonanTarget

import java.util.regex.Pattern

buildscript {
    repositories {
        mavenCentral()

        maven {
            url project.bootstrapKotlinRepo
        }
    }
}

apply plugin: 'konan'
apply plugin: 'kotlin'
apply plugin: 'kotlin.native.build-tools-conventions'

configurations {
    cli_bc
    update_tests

    nopPluginApi
    api.extendsFrom nopPluginApi
}

dependencies {
    // TODO: upgrade coroutines to common version
    api RepoDependencies.commonDependency(project, "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.7")
}
ext.testOutputRoot = rootProject.file("test.output").absolutePath

ext.platformManager = project.project(":kotlin-native").platformManager
ext.target = platformManager.targetManager(project.testTarget).target

ext.testLibraryDir = "${ext.testOutputRoot}/klib/platform/${project.target.name}"

// Add executor to run tests depending on a target
// NOTE: If this persists in a gradle daemon, environment update (e.g. an Xcode update) may lead to execution failures.
project.extensions.executor = ExecutorServiceKt.create(project)

ext.useCustomDist = UtilsKt.getUseCustomDist(project)
ext.kotlinNativeDist = UtilsKt.getKotlinNativeDist(project)
if (!useCustomDist) {
    ext.setProperty("kotlin.native.home", kotlinNativeDist.absolutePath)
    ext.setProperty("org.jetbrains.kotlin.native.home", kotlinNativeDist.absolutePath)
    ext.setProperty("konan.home", kotlinNativeDist.absolutePath)
}

compileTestKotlin {
    kotlinOptions {
        freeCompilerArgs += "-Xskip-prerelease-check"
    }
}

// Do not generate run tasks for konan built artifacts
ext.konanNoRun = true

final CacheTesting cacheTesting = CacheTestingKt.configureCacheTesting(project)
if (cacheTesting != null) {
    // Check for debug build and set the -g option.
    if (project.globalTestArgs.contains("-opt")) {
        throw new IllegalArgumentException("Cache testing should be run with debug build. " +
                "Remove -opt options from the test args")
    }
    if (!project.globalTestArgs.contains("-g")) {
        project.globalTestArgs.add("-g")
    }

    // Note: can't do this in [CacheTesting.configure] since task classes aren't accessible there.
    tasks.withType(KonanCompileNativeBinary.class).configureEach {
        dependsOn cacheTesting.buildCacheTask
        extraOpts cacheTesting.compilerArgs
    }
}

// Enable two-stage test compilation if the test_two_stage property is set.
ext.twoStageEnabled = project.hasProperty("test_two_stage")

tasks.withType(KonanCompileNativeBinary.class).configureEach {
    enableTwoStageCompilation = twoStageEnabled
}

ext.isNoopGC = project.globalTestArgs.contains("-Xbinary=gc=noop") || project.globalTestArgs.contains("-Xgc=noop")
ext.isSTWMSGC = project.globalTestArgs.contains("-Xbinary=gc=stwms") || project.globalTestArgs.contains("-Xgc=stms")
ext.isAggressiveGC = project.globalTestArgs.contains("-Xbinary=gcSchedulerType=aggressive")
ext.runtimeAssertionsPanic = false

// TODO: It also makes sense to test -g without asserts, and also to test -opt with asserts.
if (project.globalTestArgs.contains("-g") && (cacheTesting == null)) {
    tasks.withType(KonanCompileNativeBinary.class).configureEach {
        extraOpts "-Xbinary=runtimeAssertionsMode=panic"
    }
    ext.runtimeAssertionsPanic = true
}

tasks.withType(KonanCompileNativeBinary).configureEach {
    extraOpts "-XXLanguage:+ImplicitSignedToUnsignedIntegerConversion"
    extraOpts "-opt-in=kotlinx.cinterop.ExperimentalForeignApi"
}

allprojects {
    // Root directories for test output (logs, compiled files, statistics etc). Only single path must be in each set.
    // backend.native/tests
    ext.testOutputLocal = rootProject.file("$testOutputRoot/local")

    // backend.native/tests/external
    ext.testOutputExternal = rootProject.file("$testOutputRoot/external")

    // backend.native/tests/stdlib_external
    ext.testOutputStdlib = rootProject.file("$testOutputRoot/stdlib")

    // backend.native/tests/framework
    ext.testOutputFramework = rootProject.file("$testOutputRoot/framework")

    // backent.native/tests/coverage
    ext.testOutputCoverage = rootProject.file("$testOutputRoot/coverage")

    ext.testOutputFileCheck = rootProject.file("$testOutputRoot/filecheck")
}
testOutputExternal.mkdirs()
testOutputStdlib.mkdirs()

konanArtifacts {
    library('testLibrary') {
        srcDir 'testLibrary'
    }
    library('baseTestClass', targets: [target]) {
        srcFiles 'testing/library.kt'
    }
    UtilsKt.dependsOnDist(UtilsKt.findKonanBuildTask(project, "testLibrary", HostManager.@Companion.getHost()))
}
configure(project.tasks.findByName("compileKonanBaseTestClass${UtilsKt.getTestTargetSuffix(project)}")) {
  UtilsKt.dependsOnDist(it)
}

def installTestLib = tasks.register("installTestLibrary", KonanKlibInstallTask) {
    dependsOn "compileKonanTestLibraryHost"
    klib = project.provider { konanArtifacts.testLibrary.getArtifactByTarget('host') }
    repo = rootProject.file(testLibraryDir)

    doLast {
        // Remove the version in build/, so that we don't link two copies.
        def file = project.file("build/konan/libs/${project.target.name}/testLibrary.klib")
        file.delete()
    }
}

void konanc(String[] args) {
   def konancScript = isWindows() ? "konanc.bat" : "konanc"
   def konanc = "$kotlinNativeDist/bin/$konancScript"
   def allArgs = args.join(" ")
   println("$konanc $allArgs")
   "$konanc $allArgs".execute().waitFor()
}

tasks.named("clean", Delete.class) {
    doLast {
        delete(project(":kotlin-native").file(testOutputRoot))
    }
}

TaskCollection<Task> tasksOf(Class<? extends Task> type, Closure<Boolean> filter = { return true }) {
    project.tasks.withType(type).matching { it.enabled && filter(it) }
}

tasks.named("run") {
    dependsOn("sanity")
    // Note: sanity contains subsets of the tests listed below.

    dependsOn(tasksOf(KonanTest))
    // Add framework tests
    dependsOn(tasksOf(FrameworkTest))
    dependsOn(tasksOf(FileCheckTest))
}

tasks.register("sanity") {
    def platformLibsTasks =":distPlatformLibs" + ":kotlin-native:platformLibs"
    dependsOn(tasksOf(KonanTest) { task ->
        !UtilsKt.isDependsOnPlatformLibs(task)
    })
    // Add framework tests
    dependsOn(tasksOf(FrameworkTest) { task ->
        !UtilsKt.isDependsOnPlatformLibs(task)
    })
    // Add regular gradle test tasks
    dependsOn(tasksOf(Test))
    dependsOn(tasksOf(CoverageTest))
    dependsOn(tasksOf(FileCheckTest) { task ->
        // Avoid cross-compilation in a sanity run.
        task.targetName == project.target.name
    })
    dependsOn(":kotlin-native:Interop:Indexer:check")
    dependsOn(":kotlin-native:Interop:StubGenerator:check")
    dependsOn(":native:kotlin-native-utils:check")
}

boolean isExcluded(String dir) {
    // List of tests that fail due to unresolved compiler bugs
    def excluded = [ ]

    boolean result = false
    excluded.forEach {
        if (dir.endsWith(it.replace("/", File.separator))) {
            result = true
        }
    }
    return result
}

/**
 * Creates a task for a standalone test. Configures runner and adds building task.
 */
Task standaloneTest(String name, Closure configureClosure) {
    return KotlinNativeTestKt.createTest(project, name, KonanStandaloneTest) { task ->
        task.configure(configureClosure)
        if (task.enabled) {
            konanArtifacts {
                program(name, targets: [target.name]) {
                    baseDir   "$testOutputLocal/$name"
                    srcFiles  task.getSources()
                    extraOpts task.flags
                    extraOpts project.globalTestArgs
                }
            }
        }
    }
}

/**
 * Creates a task for a linking test. Configures runner and adds library and test build tasks.
 */
Task linkTest(String name, Closure<KonanLinkTest> configureClosure) {
    return KotlinNativeTestKt.createTest(project, name, KonanLinkTest) { task ->
        task.configure(configureClosure)
        if (task.enabled) {
            konanArtifacts {
                def lib = "lib$name"
                def targetName = target.name
                // build a library from KonanLinkTest::lib property
                library(lib, targets: [targetName]) {
                    srcFiles task.lib
                    baseDir  "$testOutputLocal/$name"
                    extraOpts task.flags
                    extraOpts project.globalTestArgs.findAll { !it.contains("-Xpartial-linkage") }
                }
                UtilsKt.dependsOnKonanBuildingTask(task, lib, target)

                // Build an executable with library
                program(name, targets: [targetName]) {
                    libraries {
                        klib lib
                    }
                    baseDir  "$testOutputLocal/$name"
                    srcFiles  task.getSources()
                    extraOpts task.flags
                    extraOpts project.globalTestArgs
                }
            }
        }
    }
}

/**
 * Creates a task for a dynamic test. Configures runner and adds library and test build tasks.
 */
Task dynamicTest(String name, Closure<KonanDynamicTest> configureClosure) {
    return KotlinNativeTestKt.createTest(project, name, KonanDynamicTest) { task ->
        task.configure(configureClosure)
        if (task.enabled) {
            konanArtifacts {
                def targetName = target.name
                def lib = task.interop
                if (lib != null) {
                    UtilsKt.dependsOnKonanBuildingTask(task, lib, target)
                }
                dynamic(name, targets: [targetName]) {
                    if (lib != null) {
                        libraries {
                            artifact lib
                        }
                    }
                    srcFiles task.getSources()
                    baseDir  "$testOutputLocal/$name"
                    extraOpts task.flags
                    extraOpts project.globalTestArgs
                    if (targetName == "mingw_x64" || targetName == "mingw_x86") {
                        extraOpts "-linker-option", "-Wl,--out-implib,$testOutputLocal/$name/$targetName/${name}.dll.a"
                    }
                }
            }
            def buildTask = UtilsKt.findKonanBuildTask(project, name, target)
            UtilsKt.dependsOnDist(buildTask)
        }
    }
}

linkTest("localDelegatedPropertyLink") {
    source = "lower/local_delegated_property_link/main.kt"
    lib = "lower/local_delegated_property_link/lib.kt"
}

tasks.register("sum", KonanLocalTest) {
    source = "codegen/function/sum.kt"
}

tasks.register("method_call", KonanLocalTest) {
    source = "codegen/object/method_call.kt"
}

tasks.register("fields", KonanLocalTest) {
    source = "codegen/object/fields.kt"
}

tasks.register("fields1", KonanLocalTest) {
    source = "codegen/object/fields1.kt"
}

tasks.register("fields2", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/object/fields2.kt"
}

// This test checks object layout can't be done in
// KonanLocalTest paradigm
//tasks.register("constructor", UnitKonanTest) {
//    source = "codegen/object/constructor.kt"
//}

tasks.register("objectInitialization", KonanLocalTest) {
    source = "codegen/object/initialization.kt"
}

tasks.register("objectInitialization1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/object/initialization1.kt"
}

standaloneTest("object_globalInitializer") {
    source = "codegen/object/globalInitializer.kt"
}

tasks.register("check_type", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/basics/check_type.kt"
}

tasks.register("safe_cast", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/basics/safe_cast.kt"
}

tasks.register("typealias1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/basics/typealias1.kt"
}

tasks.register("aritmetic", KonanLocalTest) {
    source = "codegen/function/arithmetic.kt"
}

tasks.register("sum1", KonanLocalTest) {
    source = "codegen/function/sum_foo_bar.kt"
}

tasks.register("sum2", KonanLocalTest) {
    source = "codegen/function/sum_imm.kt"
}

tasks.register("sum_func", KonanLocalTest) {
    source = "codegen/function/sum_func.kt"
}

tasks.register("sum_mixed", KonanLocalTest) {
    source = "codegen/function/sum_mixed.kt"
}

tasks.register("sum_illy", KonanLocalTest) {
    source = "codegen/function/sum_silly.kt"
}

tasks.register("function_defaults", KonanLocalTest) {
    source = "codegen/function/defaults.kt"
}

tasks.register("function_defaults1", KonanLocalTest) {
    source = "codegen/function/defaults1.kt"
}

tasks.register("function_defaults2", KonanLocalTest) {
    source = "codegen/function/defaults2.kt"
}

tasks.register("function_defaults3", KonanLocalTest) {
    source = "codegen/function/defaults3.kt"
}

tasks.register("function_defaults4", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/function/defaults4.kt"
}

tasks.register("function_defaults5", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/function/defaults5.kt"
}

tasks.register("function_defaults6", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/function/defaults6.kt"
}

tasks.register("function_defaults7", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/function/defaults7.kt"
}

tasks.register("function_defaults8", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/function/defaults8.kt"
}

tasks.register("function_defaults9", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/function/defaults9.kt"
}

tasks.register("function_defaults10", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/function/defaults10.kt"
}

tasks.register("function_defaults_from_fake_override", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/function/defaultsFromFakeOverride.kt"
}

tasks.register("function_defaults_with_vararg1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/function/defaultsWithVarArg1.kt"
}

tasks.register("function_defaults_with_vararg2", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/function/defaultsWithVarArg2.kt"
}

tasks.register("function_defaults_with_inline_classes", KonanLocalTest) {
    source = "codegen/function/defaultsWithInlineClasses.kt"
}

tasks.register("sum_3const", KonanLocalTest) {
    source = "codegen/function/sum_3const.kt"
}

standaloneTest("function_nothingN_returning_safe_call") {
    flags = ["-g", "-entry", "codegen.function.nothingN_returning_safe_call.main"]
    source = "codegen/function/nothingNReturningSafeCall.kt"
}

standaloneTest("unreachable_statement_after_return") {
    flags = ["-g", "-entry", "codegen.function.unreachable_statement_after_return.main"]
    source = "codegen/function/unreachableStatementAfterReturn.kt"
    useGoldenData = true
}

tasks.register("codegen_controlflow_for_loops", KonanLocalTest) {
    source = "codegen/controlflow/for_loops.kt"
    useGoldenData = true
}

tasks.register("codegen_controlflow_for_loops_types", KonanLocalTest) {
    source = "codegen/controlflow/for_loops_types.kt"
    useGoldenData = true
}

tasks.register("codegen_controlflow_for_loops_overflow", KonanLocalTest) {
    source = "codegen/controlflow/for_loops_overflow.kt"
    useGoldenData = true
}

tasks.register("codegen_controlflow_for_loops_errors", KonanLocalTest) {
    source = "codegen/controlflow/for_loops_errors.kt"
    useGoldenData = true
}

tasks.register("codegen_controlflow_for_loops_empty_range", KonanLocalTest) {
    source = "codegen/controlflow/for_loops_empty_range.kt"
    useGoldenData = true
}

tasks.register("codegen_controlflow_for_loops_nested", KonanLocalTest) {
    source = "codegen/controlflow/for_loops_nested.kt"
    useGoldenData = true
}

tasks.register("codegen_controlflow_for_loops_coroutines", KonanLocalTest) {
    source = "codegen/controlflow/for_loops_coroutines.kt"
    useGoldenData = true
}

tasks.register("codegen_controlflow_for_loops_let_with_nullable", KonanLocalTest) {
    source = "codegen/controlflow/for_loops_let_with_nullable.kt"
    useGoldenData = true
}

tasks.register("codegen_controlflow_for_loops_call_order", KonanLocalTest) {
    source = "codegen/controlflow/for_loops_call_order.kt"
    useGoldenData = true
}

tasks.register("codegen_controlflow_for_loops_array_indices", KonanLocalTest) {
    source = "codegen/controlflow/for_loops_array_indices.kt"
    useGoldenData = true
}

tasks.register("codegen_controlflow_for_loops_array", KonanLocalTest) {
    source = "codegen/controlflow/for_loops_array.kt"
    useGoldenData = true
}

tasks.register("codegen_controlflow_for_loops_array_nested", KonanLocalTest) {
    source = "codegen/controlflow/for_loops_array_nested.kt"
    useGoldenData = true
}

tasks.register("codegen_controlflow_for_loops_array_side_effects", KonanLocalTest) {
    source = "codegen/controlflow/for_loops_array_side_effects.kt"
    useGoldenData = true
}

tasks.register("codegen_controlflow_for_loops_array_break_continue", KonanLocalTest) {
    source = "codegen/controlflow/for_loops_array_break_continue.kt"
    useGoldenData = true
}

tasks.register("codegen_controlflow_for_loops_array_mutation", KonanLocalTest) {
    source = "codegen/controlflow/for_loops_array_mutation.kt"
    useGoldenData = true
}

tasks.register("codegen_controlflow_for_loops_array_nullable", KonanLocalTest) {
    source = "codegen/controlflow/for_loops_array_nullable.kt"
    useGoldenData = true
}

tasks.register("local_variable", KonanLocalTest) {
    source = "codegen/basics/local_variable.kt"
}

tasks.register("canonical_name", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/basics/canonical_name.kt"
}

tasks.register("cast_simple", KonanLocalTest) {
    source = "codegen/basics/cast_simple.kt"
}

tasks.register("cast_null", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/basics/cast_null.kt"
}

tasks.register("unchecked_cast1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/basics/unchecked_cast1.kt"
}

tasks.register("unchecked_cast2", KonanLocalTest) {
    enabled = false
    useGoldenData = true
    source = "codegen/basics/unchecked_cast2.kt"
}

tasks.register("unchecked_cast3", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/basics/unchecked_cast3.kt"
}

tasks.register("unchecked_cast4", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/basics/unchecked_cast4.kt"
}

tasks.register("null_check", KonanLocalTest) {
    source = "codegen/basics/null_check.kt"
}

tasks.register("array_to_any", KonanLocalTest) {
    source = "codegen/basics/array_to_any.kt"
}

standaloneTest("runtime_basic_init") {
    source = "runtime/basic/init.kt"
    expectedExitStatus = 0
}

standaloneTest("runtime_basic_exit") {
    source = "runtime/basic/exit.kt"
    expectedExitStatus = 42
}

tasks.register("runtime_random", KonanLocalTest) {
    source = "runtime/basic/random.kt"
}

tasks.register("runtime_basic_simd", KonanLocalTest) {
    source = "runtime/basic/simd.kt"
}

tasks.register("runtime_worker_random", KonanLocalTest) {
    source = "runtime/basic/worker_random.kt"
}

tasks.register("hello0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/basic/hello0.kt"
}

tasks.register("stringTrim", KonanLocalTest) {
    source = "codegen/stringTrim/stringTrim.kt"
}

standaloneTest("hello1") {
   useGoldenData = true
   useTestData = true
   source = "runtime/basic/hello1.kt"
}

standaloneTest("hello2") {
   useGoldenData = true
   useTestData = true
   source = "runtime/basic/hello2.kt"
}

standaloneTest("readlnOrNull_empty") {
    useGoldenData = true
    useTestData = true
    source = "runtime/basic/readlnOrNull_empty.kt"
}

standaloneTest("readln_empty") {
    useTestData = true
    outputChecker = { s -> s.contains("ReadAfterEOFException") }
    expectedExitStatusChecker = { it != 0 }
    source = "runtime/basic/readln_empty.kt"
}

standaloneTest("readln_alone_CR") {
    useGoldenData = true
    useTestData = true
    source = "runtime/basic/readln_alone_CR.kt"
}

standaloneTest("readln_empty_new_line") {
    useGoldenData = true
    useTestData = true
    source = "runtime/basic/readln_empty_new_line.kt"
}

standaloneTest("readln_multiline") {
    useGoldenData = true
    useTestData = true
    source = "runtime/basic/readln_multiline.kt"
}

standaloneTest("readln_CR_and_CRLF") {
    useGoldenData = true
    useTestData = true
    source = "runtime/basic/readln_CR_and_CRLF.kt"
}

standaloneTest("readln_long_line") {
    useGoldenData = true
    useTestData = true
    source = "runtime/basic/readln_long_line.kt"
}

standaloneTest("readln_cyrillic") {
    useGoldenData = true
    useTestData = true
    source = "runtime/basic/readln_cyrillic.kt"
}

standaloneTest("readln_multiple_empty_new_lines") {
    useGoldenData = true
    useTestData = true
    source = "runtime/basic/readln_multiple_empty_new_lines.kt"
}

tasks.register("hello3", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/basic/hello3.kt"
}

tasks.register("hello4", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/basic/hello4.kt"
}

standaloneTest('enumEquals') {
    useGoldenData = true
    source = "runtime/basic/enum_equals.kt"
    flags = ['-XXLanguage:-ProhibitComparisonOfIncompatibleEnums', '-e', 'runtime.basic.enum_equals.main']
}

standaloneTest("entry0") {
    useGoldenData = true
    source = "runtime/basic/entry0.kt"
    flags = ["-entry", "runtime.basic.entry0.main"]
}

standaloneTest("entry1") {
    useGoldenData = true
    source = "runtime/basic/entry1.kt"
    flags = ["-entry", "foo"]
}

linkTest("entry2") {
    useGoldenData = true
    source = "runtime/basic/entry2.kt"
    lib = "runtime/basic/libentry2.kt"
    flags = ["-entry", "foo"]
}

standaloneTest("entry3") {
    useGoldenData = true
    source = "runtime/basic/entry3.kt"
    flags = ["-entry", "bar"]
}

standaloneTest("entry4") {
    useGoldenData = true
    source = "runtime/basic/entry4.kt"
}

standaloneTest("readline0") {
    useGoldenData = true
    useTestData = true
    source = "runtime/basic/readline0.kt"
}

standaloneTest("readline1") {
    useGoldenData = true
    useTestData = true
    source = "runtime/basic/readline1.kt"
}

tasks.register("tostring0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/basic/tostring0.kt"
}

tasks.register("tostring1", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/basic/tostring1.kt"
}

tasks.register("tostring2", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/basic/tostring2.kt"
}

tasks.register("tostring3", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/basic/tostring3.kt"
}

tasks.register("tostring4", KonanLocalTest) {
    source = "runtime/basic/tostring4.kt"
}

tasks.register("empty_substring", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/basic/empty_substring.kt"
}

standaloneTest("cleaner_basic") {
    enabled = !isNoopGC
    source = "runtime/basic/cleaner_basic.kt"
    flags = ['-tr', '-opt-in=kotlin.native.internal.InternalForKotlinNative']
}

standaloneTest("collect_reference_field_values") {
    enabled = !isNoopGC
    source = "runtime/basic/collectReferenceFieldValues.kt"
    flags = ['-tr', '-opt-in=kotlin.native.internal.InternalForKotlinNative']
}

standaloneTest("cleaner_workers") {
    enabled = !isNoopGC
    source = "runtime/basic/cleaner_workers.kt"
    flags = ['-tr', '-opt-in=kotlin.native.internal.InternalForKotlinNative']
}

standaloneTest("cleaner_in_main_with_checker") {
    enabled = !isNoopGC
    source = "runtime/basic/cleaner_in_main_with_checker.kt"
    useGoldenData = true
}

standaloneTest("cleaner_in_main_without_checker") {
    source = "runtime/basic/cleaner_in_main_without_checker.kt"
    useGoldenData = true
}

standaloneTest("cleaner_leak_without_checker") {
    source = "runtime/basic/cleaner_leak_without_checker.kt"
    useGoldenData = true
}

standaloneTest("cleaner_leak_with_checker") {
    enabled = !isNoopGC
    source = "runtime/basic/cleaner_leak_with_checker.kt"
    expectedExitStatusChecker = { it != 0 }
    outputChecker = { s -> (s =~ /Cleaner (0x)?[0-9a-fA-F]+ was disposed during program exit/).find() }
}

standaloneTest("cleaner_in_tls_main_without_checker") {
    source = "runtime/basic/cleaner_in_tls_main_without_checker.kt"
}

standaloneTest("cleaner_in_tls_main_with_checker") {
    enabled = !isNoopGC
    source = "runtime/basic/cleaner_in_tls_main_with_checker.kt"
    expectedExitStatusChecker = { it != 0 }
    outputChecker = { s -> (s =~ /Cleaner (0x)?[0-9a-fA-F]+ was disposed during program exit/).find() }
}

standaloneTest("cleaner_in_tls_worker") {
    enabled = !isNoopGC
    source = "runtime/basic/cleaner_in_tls_worker.kt"
    flags = ['-opt-in=kotlin.native.internal.InternalForKotlinNative']
}

standaloneTest("worker_bound_reference0") {
    source = "runtime/concurrent/worker_bound_reference0.kt"
    flags = ['-tr']

    if (isNoopGC) {
        def exclude = [
                "*.testCollect",
                "*.testCollectFrozen",
                "*.testCollectInWorkerFrozen",
                "*.collectCyclicGarbage",
                "*.collectCyclicGarbageWithAtomicsFrozen",
                "*.collectCrossThreadCyclicGarbageWithAtomicsFrozen"
        ]
        arguments += ["--ktest_filter=*-${exclude.join(":")}"]
    }
}

tasks.register("worker0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/workers/worker0.kt"
}

tasks.register("worker1", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/workers/worker1.kt"
}

tasks.register("worker2", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/workers/worker2.kt"
}

tasks.register("worker3", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/workers/worker3.kt"
}

tasks.register("worker4", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/workers/worker4.kt"
}

// This tests changes main thread worker queue state, so better be executed alone.
standaloneTest("worker5") {
    useGoldenData = true
    source = "runtime/workers/worker5.kt"
}

tasks.register("worker6", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/workers/worker6.kt"
}

tasks.register("worker7", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/workers/worker7.kt"
}

tasks.register("worker8", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/workers/worker8.kt"
}

tasks.register("worker9_experimentalMM", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/workers/worker9_experimentalMM.kt"
}

tasks.register("worker10", KonanLocalTest) {
    enabled = !isNoopGC
    useGoldenData = true
    source = "runtime/workers/worker10.kt"
}

tasks.register("worker11", KonanLocalTest) {
    enabled = !isAggressiveGC // TODO: Investigate why too slow
    useGoldenData = true
    source = "runtime/workers/worker11.kt"
}

tasks.register("worker_exception_messages", KonanLocalTest) {
    source = "runtime/workers/worker_exception_messages.kt"
}

standaloneTest("worker_exceptions") {
    flags = ["-tr", "-Xworker-exception-handling=use-hook"]
    outputChecker = {
        !it.contains("testExecuteAfterStartQuiet error") && it.contains("testExecuteStart error") && !it.contains("testExecuteStartQuiet error")
    }
    source = "runtime/workers/worker_exceptions.kt"
}

standaloneTest("worker_exceptions_legacy") {
    flags = ["-tr", "-Xworker-exception-handling=legacy"]
    outputChecker = {
        it.contains("testExecuteAfterStartLegacy error") && it.contains("testExecuteStartLegacy error")
    }
    source = "runtime/workers/worker_exceptions_legacy.kt"
}

standaloneTest("worker_exceptions_terminate") {
    flags = ["-Xworker-exception-handling=use-hook"]
    expectedExitStatusChecker = { it != 0 }
    outputChecker = {
        it.contains("some error") && !it.contains("Will not happen")
    }
    source = "runtime/workers/worker_exceptions_terminate.kt"
}

standaloneTest("worker_exceptions_terminate_legacy") {
    flags = ["-Xworker-exception-handling=legacy"]
    outputChecker = {
        it.contains("some error") && it.contains("Will not happen")
    }
    source = "runtime/workers/worker_exceptions_terminate.kt"
}

standaloneTest("worker_exceptions_terminate_hook") {
    flags = ["-Xworker-exception-handling=use-hook"]
    outputChecker = {
        it.contains("hook called") && !it.contains("some error") && it.contains("Will happen")
    }
    source = "runtime/workers/worker_exceptions_terminate_hook.kt"
}

standaloneTest("worker_exceptions_terminate_hook_legacy") {
    flags = ["-Xworker-exception-handling=legacy"]
    outputChecker = {
        !it.contains("hook called") && it.contains("some error") && it.contains("Will happen")
    }
    source = "runtime/workers/worker_exceptions_terminate_hook.kt"
}

standaloneTest("worker_exceptions_terminate_current") {
    flags = ["-Xworker-exception-handling=use-hook"]
    expectedExitStatusChecker = { it != 0 }
    outputChecker = {
        it.contains("some error") && !it.contains("Will not happen")
    }
    source = "runtime/workers/worker_exceptions_terminate_current.kt"
}

standaloneTest("worker_exceptions_terminate_current_legacy") {
    flags = ["-Xworker-exception-handling=legacy"]
    outputChecker = {
        it.contains("some error") && it.contains("Will not happen")
    }
    source = "runtime/workers/worker_exceptions_terminate_current.kt"
}

standaloneTest("worker_exceptions_terminate_hook_current") {
    flags = ["-Xworker-exception-handling=use-hook"]
    outputChecker = {
        it.contains("hook called") && !it.contains("some error") && it.contains("Will happen")
    }
    source = "runtime/workers/worker_exceptions_terminate_hook_current.kt"
}

standaloneTest("worker_exceptions_terminate_hook_current_legacy") {
    flags = ["-Xworker-exception-handling=legacy"]
    outputChecker = {
        !it.contains("hook called") && it.contains("some error") && it.contains("Will happen")
    }
    source = "runtime/workers/worker_exceptions_terminate_hook_current.kt"
}

standaloneTest("worker_threadlocal_no_leak") {
    source = "runtime/workers/worker_threadlocal_no_leak.kt"
}

tasks.register("worker_list_workers", KonanLocalTest) {
    source = "runtime/workers/worker_list_workers.kt"
}

standaloneTest("freeze_disabled") {
    enabled = !isNoopGC
    flags = ["-tr"]
    source = "runtime/workers/freeze_disabled.kt"
    testLogger = KonanTest.Logger.SILENT
}

tasks.register("atomicSmokeTest", KonanLocalTest) {
    source = "runtime/atomics/atomic_smoke.kt"
}

tasks.register("atomicStressTest", KonanLocalTest) {
    source = "runtime/atomics/atomic_stress.kt"
}

tasks.register("atomic0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/atomics/atomic0.kt"
}

standaloneTest("atomic1") {
    // Note: This test reproduces a race, so it'll start flaking if problem is reintroduced.
    enabled = false // Needs USE_CYCLIC_GC, which is disabled.
    source = "runtime/atomics/atomic1.kt"
}

tasks.register("atomicArraySmokeTest", KonanLocalTest) {
    source = "runtime/atomics/atomic_array_smoke.kt"
}

tasks.register("atomicArrayStressTest", KonanLocalTest) {
    source = "runtime/atomics/atomic_array_stress.kt"
}

tasks.register("lazy0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/workers/lazy0.kt"
}

tasks.register("lazy1", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/workers/lazy1.kt"
}

standaloneTest("lazy2") {
    useGoldenData = true
    source = "runtime/workers/lazy2.kt"
}

standaloneTest("lazy3") {
    enabled = !isNoopGC
    source = "runtime/workers/lazy3.kt"
}

tasks.register("lazy4", KonanLocalTest) {
    enabled = !isAggressiveGC // TODO: Investigate why too slow
    source = "runtime/workers/lazy4.kt"
}

tasks.register("mutableData1", KonanLocalTest) {
    source = "runtime/workers/mutableData1.kt"
}

tasks.register("enumIdentity", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/workers/enum_identity.kt"
}

standaloneTest("leakWorker") {
    source = "runtime/workers/leak_worker.kt"
    expectedExitStatusChecker = { it != 0 }
    outputChecker = { s -> s.contains("Unfinished workers detected, 1 workers leaked!") }
}

standaloneTest("leakMemoryWithWorkerTermination") {
    source = "runtime/workers/leak_memory_with_worker_termination.kt"
}

tasks.register("superFunCall", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/basics/superFunCall.kt"
}

tasks.register("superGetterCall", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/basics/superGetterCall.kt"
}

tasks.register("superSetterCall", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/basics/superSetterCall.kt"
}

tasks.register("enum0", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/enum/test0.kt"
}

tasks.register("enum1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/enum/test1.kt"
}

tasks.register("enum_valueOf", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/enum/valueOf.kt"
}

tasks.register("enum_values", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/enum/values.kt"
}

tasks.register("enum_vCallNoEntryClass", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/enum/vCallNoEntryClass.kt"
}

tasks.register("enum_vCallWithEntryClass", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/enum/vCallWithEntryClass.kt"
}

tasks.register("enum_companionObject", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/enum/companionObject.kt"
}

tasks.register("enum_interfaceCallNoEntryClass", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/enum/interfaceCallNoEntryClass.kt"
}

tasks.register("enum_interfaceCallWithEntryClass", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/enum/interfaceCallWithEntryClass.kt"
}

linkTest("enum_linkTest") {
    useGoldenData = true
    source = "codegen/enum/linkTest_main.kt"
    lib = "codegen/enum/linkTest_lib.kt"
}

linkTest("enum_openMethodNoOverrides") {
    useGoldenData = true
    source = "codegen/enum/openMethodNoOverrides_main.kt"
    lib = "codegen/enum/openMethodNoOverrides_lib.kt"
}

tasks.register("enum_varargParam", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/enum/varargParam.kt"
}

tasks.register("enum_nested", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/enum/nested.kt"
}

tasks.register("enum_isFrozen", KonanLocalTest) {
    source = "codegen/enum/isFrozen.kt"
}

tasks.register("enum_loop", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/enum/loop.kt"
}

tasks.register("enum_reorderedArguments", KonanLocalTest) {
    source = "codegen/enum/reorderedArguments.kt"
}

standaloneTest('switchLowering') {
    useGoldenData = true
    source = "codegen/enum/switchLowering.kt"
    flags = ['-XXLanguage:-ProhibitComparisonOfIncompatibleEnums', '-e', 'codegen.enum.switchLowering.main']
}

tasks.register("enum_lambdaInDefault", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/enum/lambdaInDefault.kt"
}

linkTest("mangling") {
    useGoldenData = true
    source = "mangling/mangling.kt"
    lib = "mangling/manglinglib.kt"
}

tasks.register("innerClass_simple", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/innerClass/simple.kt"
}

tasks.register("innerClass_getOuterVal", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/innerClass/getOuterVal.kt"
}

tasks.register("innerClass_generic", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/innerClass/generic.kt"
}

tasks.register("innerClass_doubleInner", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/innerClass/doubleInner.kt"
}

tasks.register("innerClass_qualifiedThis", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/innerClass/qualifiedThis.kt"
}

tasks.register("innerClass_superOuter", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/innerClass/superOuter.kt"
}

tasks.register("innerClass_noPrimaryConstructor", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/innerClass/noPrimaryConstructor.kt"
}

tasks.register("innerClass_secondaryConstructor", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/innerClass/secondaryConstructor.kt"
}

linkTest("innerClass_linkTest") {
    source = "codegen/innerClass/linkTest_main.kt"
    lib = "codegen/innerClass/linkTest_lib.kt"
}

linkTest("innerClass_inheritance_linkTest") {
    useGoldenData = true
    source = "codegen/innerClass/inheritance_linkTest_main.kt"
    lib = "codegen/innerClass/inheritance_linkTest_lib.kt"
}

linkTest("innerClass_inheritance2_linkTest") {
    useGoldenData = true
    source = "codegen/innerClass/inheritance2_linkTest_main.kt"
    lib = "codegen/innerClass/inheritance2_linkTest_lib.kt"
}

linkTest("innerClass_inheritance3_linkTest") {
    useGoldenData = true
    source = "codegen/innerClass/inheritance3_linkTest_main.kt"
    lib = "codegen/innerClass/inheritance3_linkTest_lib.kt"
}

tasks.register("localClass_localHierarchy", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/localClass/localHierarchy.kt"
}

standaloneTest("objectDeclaration_globalConstants") {
    disabled = (cacheTesting != null) // Cache is not compatible with -opt.
    flags = ["-opt", "-opt-in=kotlin.native.internal.InternalForKotlinNative", "-tr"]
    source = "codegen/objectDeclaration/globalConstants.kt"
}

tasks.register("object_isFrozen", KonanLocalTest) {
    source = "codegen/objectDeclaration/isFrozen.kt"
}

tasks.register("localClass_objectExpressionInProperty", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/localClass/objectExpressionInProperty.kt"
}

tasks.register("localClass_objectExpressionInInitializer", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/localClass/objectExpressionInInitializer.kt"
}

tasks.register("localClass_innerWithCapture", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/localClass/innerWithCapture.kt"
}

tasks.register("localClass_innerTakesCapturedFromOuter", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/localClass/innerTakesCapturedFromOuter.kt"
}

tasks.register("localClass_virtualCallFromConstructor", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/localClass/virtualCallFromConstructor.kt"
}

tasks.register("localClass_noPrimaryConstructor", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/localClass/noPrimaryConstructor.kt"
}

tasks.register("localClass_localFunctionCallFromLocalClass", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/localClass/localFunctionCallFromLocalClass.kt"
}

tasks.register("localClass_localFunctionInLocalClass", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/localClass/localFunctionInLocalClass.kt"
}

tasks.register("localClass_tryCatch", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/localClass/tryCatch.kt"
}

tasks.register("function_localFunction", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/function/localFunction.kt"
}

tasks.register("function_localFunction2", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/function/localFunction2.kt"
}

tasks.register("function_localFunction3", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/function/localFunction3.kt"
}

tasks.register("initializers_correctOrder1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/initializers/correctOrder1.kt"
}

tasks.register("initializers_correctOrder2", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/initializers/correctOrder2.kt"
}

standaloneTest("initializers_correctOrder3") {
    source = "codegen/initializers/correctOrder3.kt"
    useGoldenData = true
}

standaloneTest("initializers_globalInitedAfterAccessingFile") {
    source = "codegen/initializers/globalInitedAfterAccessingFile.kt"
}

standaloneTest("initializers_globalNotInitedAfterAccessingClassInternals") {
    source = "codegen/initializers/globalNotInitedAfterAccessingClassInternals.kt"
}

standaloneTest("initializers_globalInitedBeforeThreadLocal") {
    source = "codegen/initializers/globalInitedBeforeThreadLocal.kt"
}

standaloneTest("initializers_eagerInitializationGlobal1") {
    source = "codegen/initializers/eagerInitializationGlobal1.kt"
}

standaloneTest("initializers_eagerInitializationGlobal2") {
    source = "codegen/initializers/eagerInitializationGlobal2.kt"
}

standaloneTest("initializers_eagerInitializationThreadLocal1") {
    source = "codegen/initializers/eagerInitializationThreadLocal1.kt"
}

standaloneTest("initializers_eagerInitializationThreadLocal2") {
    source = "codegen/initializers/eagerInitializationThreadLocal2.kt"
}

standaloneTest("initializers_testInfrastructure") {
    source = "codegen/initializers/testInfrastructure.kt"
    flags = ["-tr"]
}

standaloneTest("initializers_workers1") {
    source = "codegen/initializers/workers1.kt"
    useGoldenData = true
}

standaloneTest("initializers_workers2") {
    source = "codegen/initializers/workers2.kt"
    useGoldenData = true
}

standaloneTest("initializers_when1") {
    source = "codegen/initializers/when1.kt"
    useGoldenData = true
}

standaloneTest("initializers_when2") {
    source = "codegen/initializers/when2.kt"
    useGoldenData = true
}

standaloneTest("initializers_throw1") {
    source = "codegen/initializers/throw1.kt"
    useGoldenData = true
}

standaloneTest("initializers_throw2") {
    source = "codegen/initializers/throw2.kt"
    useGoldenData = true
}

standaloneTest("initializers_while1") {
    source = "codegen/initializers/while1.kt"
    useGoldenData = true
}

standaloneTest("initializers_while2") {
    source = "codegen/initializers/while2.kt"
    useGoldenData = true
}

standaloneTest("initializers_while3") {
    source = "codegen/initializers/while3.kt"
    useGoldenData = true
}

standaloneTest("initializers_return1") {
    source = "codegen/initializers/return1.kt"
    useGoldenData = true
}

standaloneTest("initializers_return2") {
    source = "codegen/initializers/return2.kt"
    useGoldenData = true
}

standaloneTest("initializers_object") {
    source = "codegen/initializers/object.kt"
    flags = ['-Xir-property-lazy-initialization=enable']
}

linkTest("initializers_linkTest1") {
    useGoldenData = true
    source = "codegen/initializers/linkTest1_main.kt"
    lib = "codegen/initializers/linkTest1_lib.kt"
}

linkTest("initializers_linkTest2") {
    useGoldenData = true
    source = "codegen/initializers/linkTest2_main.kt"
    lib = "codegen/initializers/linkTest2_lib.kt"
}

linkTest("initializers_sharedVarInInitBlock") {
    source = "codegen/initializers/sharedVarInInitBlock_main.kt"
    lib = "codegen/initializers/sharedVarInInitBlock_lib.kt"
}

standaloneTest("initializers_static") {
    source = "codegen/initializers/static.kt"
    flags = ['-opt-in=kotlin.native.internal.InternalForKotlinNative', "-tr"]
}

tasks.register("arithmetic_basic", KonanLocalTest) {
    source = "codegen/arithmetic/basic.kt"
}

tasks.register("arithmetic_division", KonanLocalTest) {
    source = "codegen/arithmetic/division.kt"
}

tasks.register("arithmetic_github1856", KonanLocalTest) {
    source = "codegen/arithmetic/github1856.kt"
}

tasks.register("bridges_test0", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/test0.kt"
}

tasks.register("bridges_test1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/test1.kt"
}

tasks.register("bridges_test2", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/test2.kt"
}

tasks.register("bridges_test3", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/test3.kt"
}

tasks.register("bridges_test4", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/test4.kt"
}

tasks.register("bridges_test5", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/test5.kt"
}

tasks.register("bridges_test6", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/test6.kt"
}

tasks.register("bridges_test7", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/test7.kt"
}

tasks.register("bridges_test8", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/test8.kt"
}

tasks.register("bridges_test9", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/test9.kt"
}

tasks.register("bridges_test10", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/test10.kt"
}

tasks.register("bridges_test11", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/test11.kt"
}

tasks.register("bridges_test12", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/test12.kt"
}

tasks.register("bridges_test13", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/test13.kt"
}

tasks.register("bridges_test14", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/test14.kt"
}

tasks.register("bridges_test15", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/test15.kt"
}

tasks.register("bridges_test16", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/test16.kt"
}

tasks.register("bridges_test17", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/test17.kt"
}

tasks.register("bridges_test18", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/test18.kt"
}

linkTest("bridges_linkTest") {
    useGoldenData = true
    source = "codegen/bridges/linkTest_main.kt"
    lib = "codegen/bridges/linkTest_lib.kt"
}

linkTest("bridges_linkTest2") {
    useGoldenData = true
    source = "codegen/bridges/linkTest2_main.kt"
    lib = "codegen/bridges/linkTest2_lib.kt"
}

tasks.register("bridges_special", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/bridges/special.kt"
}

tasks.register("bridges_specialGeneric", KonanLocalTest) {
    source = "codegen/bridges/specialGeneric.kt"
}

tasks.register("bridges_nativePointed", KonanLocalTest) {
    source = "codegen/bridges/nativePointed.kt"
}

tasks.register("returnTypeSignature", KonanLocalTest) {
    source = "codegen/bridges/returnTypeSignature.kt"
}

tasks.register("classDelegation_method", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/classDelegation/method.kt"
}

tasks.register("classDelegation_property", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/classDelegation/property.kt"
}

tasks.register("classDelegation_generic", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/classDelegation/generic.kt"
}

tasks.register("classDelegation_withBridge", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/classDelegation/withBridge.kt"
}

linkTest("classDelegation_linkTest") {
    useGoldenData = true
    source = "codegen/classDelegation/linkTest_main.kt"
    lib = "codegen/classDelegation/linkTest_lib.kt"
}

standaloneTest("contracts") {
    flags = [ '-opt-in=kotlin.RequiresOptIn', '-tr' ]
    source = "codegen/contracts/contracts.kt"
}

tasks.register("delegatedProperty_simpleVal", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/delegatedProperty/simpleVal.kt"
}

tasks.register("delegatedProperty_simpleVar", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/delegatedProperty/simpleVar.kt"
}

tasks.register("delegatedProperty_packageLevel", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/delegatedProperty/packageLevel.kt"
}

tasks.register("delegatedProperty_local", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/delegatedProperty/local.kt"
}

linkTest("delegatedProperty_delegatedOverride") {
    useGoldenData = true
    source = "codegen/delegatedProperty/delegatedOverride_main.kt"
    lib = "codegen/delegatedProperty/delegatedOverride_lib.kt"
}

linkTest("delegatedProperty_correctFieldsOrder") {
    useGoldenData = true
    source = "codegen/delegatedProperty/correctFieldsOrder_main.kt"
    lib = "codegen/delegatedProperty/correctFieldsOrder_lib.kt"
}

tasks.register("delegatedProperty_lazy", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/delegatedProperty/lazy.kt"
}

tasks.register("delegatedProperty_observable", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/delegatedProperty/observable.kt"
}

tasks.register("delegatedProperty_map", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/delegatedProperty/map.kt"
}

tasks.register("propertyCallableReference_valClass", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/propertyCallableReference/valClass.kt"
}

tasks.register("propertyCallableReference_valModule", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/propertyCallableReference/valModule.kt"
}

tasks.register("propertyCallableReference_varClass", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/propertyCallableReference/varClass.kt"
}

tasks.register("propertyCallableReference_varModule", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/propertyCallableReference/varModule.kt"
}

tasks.register("propertyCallableReference_valExtension", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/propertyCallableReference/valExtension.kt"
}

tasks.register("propertyCallableReference_varExtension", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/propertyCallableReference/varExtension.kt"
}

linkTest("propertyCallableReference_linkTest") {
    useGoldenData = true
    source = "codegen/propertyCallableReference/linkTest_main.kt"
    lib = "codegen/propertyCallableReference/linkTest_lib.kt"
}

tasks.register("propertyCallableReference_dynamicReceiver", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/propertyCallableReference/dynamicReceiver.kt"
}

tasks.register("lateinit_initialized", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lateinit/initialized.kt"
}

tasks.register("lateinit_notInitialized", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lateinit/notInitialized.kt"
}

tasks.register("lateinit_inBaseClass", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lateinit/inBaseClass.kt"
}

tasks.register("lateinit_localInitialized", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lateinit/localInitialized.kt"
}

tasks.register("lateinit_localNotInitialized", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lateinit/localNotInitialized.kt"
}

tasks.register("lateinit_localCapturedInitialized", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lateinit/localCapturedInitialized.kt"
}

tasks.register("lateinit_localCapturedNotInitialized", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lateinit/localCapturedNotInitialized.kt"
}

tasks.register("lateinit_isInitialized", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lateinit/isInitialized.kt"
}

tasks.register("lateinit_globalIsInitialized", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lateinit/globalIsInitialized.kt"
}

tasks.register("lateinit_innerIsInitialized", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lateinit/innerIsInitialized.kt"
}

tasks.register("sanity_assertions_enabled_for_local_tests", KonanLocalTest) {
    source = "sanity/assertions_enabled_for_local_tests.kt"
}

tasks.register("kclass0", KonanLocalTest) {
    source = "codegen/kclass/kclass0.kt"
}

tasks.register("kclass1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/kclass/kclass1.kt"
}

tasks.register("kclassEnumArgument", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/kclass/kClassEnumArgument.kt"
}

tasks.register("ktype1", KonanLocalTest) {
    source = "codegen/ktype/ktype1.kt"
}

tasks.register("ktype_nonReified", KonanLocalTest) {
    source = "codegen/ktype/nonReified.kt"
}

tasks.register("associatedObjects1", KonanLocalTest) {
    source = "codegen/associatedObjects/associatedObjects1.kt"
}

tasks.register("coroutines_simple", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/simple.kt"
}

tasks.register("coroutines_degenerate1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/degenerate1.kt"
}

tasks.register("coroutines_degenerate2", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/degenerate2.kt"
}

tasks.register("coroutines_withReceiver", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/withReceiver.kt"
}

tasks.register("coroutines_correctOrder1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/correctOrder1.kt"
}

tasks.register("coroutines_controlFlow_chain", KonanLocalTest) {
    source = "codegen/coroutines/controlFlow_chain.kt"
}

tasks.register("coroutines_controlFlow_if1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/controlFlow_if1.kt"
}

tasks.register("coroutines_controlFlow_if2", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/controlFlow_if2.kt"
}

tasks.register("coroutines_controlFlow_finally1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/controlFlow_finally1.kt"
}

tasks.register("coroutines_controlFlow_finally2", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/controlFlow_finally2.kt"
}

tasks.register("coroutines_controlFlow_finally3", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/controlFlow_finally3.kt"
}

tasks.register("coroutines_controlFlow_finally4", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/controlFlow_finally4.kt"
}

tasks.register("coroutines_controlFlow_finally5", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/controlFlow_finally5.kt"
}

tasks.register("coroutines_controlFlow_finally6", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/controlFlow_finally6.kt"
}

tasks.register("coroutines_controlFlow_finally7", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/controlFlow_finally7.kt"
}

tasks.register("coroutines_controlFlow_inline1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/controlFlow_inline1.kt"
}

tasks.register("coroutines_controlFlow_inline2", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/controlFlow_inline2.kt"
}

tasks.register("coroutines_controlFlow_inline3", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/controlFlow_inline3.kt"
}

tasks.register("coroutines_controlFlow_tryCatch1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/controlFlow_tryCatch1.kt"
}

tasks.register("coroutines_controlFlow_tryCatch2", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/controlFlow_tryCatch2.kt"
}

tasks.register("coroutines_controlFlow_tryCatch3", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/controlFlow_tryCatch3.kt"
}

tasks.register("coroutines_controlFlow_tryCatch4", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/controlFlow_tryCatch4.kt"
}

tasks.register("coroutines_controlFlow_tryCatch5", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/controlFlow_tryCatch5.kt"
}

tasks.register("coroutines_controlFlow_while1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/controlFlow_while1.kt"
}

tasks.register("coroutines_controlFlow_while2", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/controlFlow_while2.kt"
}

tasks.register("coroutines_returnsNothing1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/returnsNothing1.kt"
}

tasks.register("coroutines_returnsUnit1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/returnsUnit1.kt"
}

tasks.register("coroutines_coroutineContext1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/coroutineContext1.kt"
}

tasks.register("coroutines_coroutineContext2", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/coroutineContext2.kt"
}

tasks.register("coroutines_anonymousObject", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/anonymousObject.kt"
}

tasks.register("coroutines_functionReference_simple", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/functionReference_simple.kt"
}

tasks.register("coroutines_functionReference_eqeq_name", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/functionReference_eqeq_name.kt"
}

tasks.register("coroutines_functionReference_invokeAsFunction", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/functionReference_invokeAsFunction.kt"
}

tasks.register("coroutines_functionReference_lambdaAsSuspendLambda", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/functionReference_lambdaAsSuspendLambda.kt"
}

tasks.register("coroutines_kt41394", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/kt41394.kt"
}

tasks.register("coroutines_inheritance", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/coroutines/inheritance.kt"
}

standaloneTest('coroutines_suspendConversion') {
    useGoldenData = true
    source = "codegen/coroutines/suspendConversion.kt"
    flags = ['-XXLanguage:+SuspendConversion']
}

tasks.register("AbstractMutableCollection", KonanLocalTest) {
    expectedExitStatus = 0
    source = "runtime/collections/AbstractMutableCollection.kt"
}

tasks.register("BitSet", KonanLocalTest) {
    expectedExitStatus = 0
    source = "runtime/collections/BitSet.kt"
}

tasks.register("stack_array", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/collections/stack_array.kt"
}

tasks.register("array0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/collections/array0.kt"
}

tasks.register("array1", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/collections/array1.kt"
}

tasks.register("array2", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/collections/array2.kt"
}

tasks.register("array3", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/collections/array3.kt"
}

tasks.register("array4", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/collections/array4.kt"
}

tasks.register("array5", KonanLocalTest) {
    source = "runtime/collections/array5.kt"
}

tasks.register("typed_array0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/collections/typed_array0.kt"
}

tasks.register("typed_array1", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/collections/typed_array1.kt"
}


tasks.register("sort0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/collections/sort0.kt"
}

tasks.register("sort1", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/collections/sort1.kt"
}

tasks.register("sortWith", KonanLocalTest) {
    source = "runtime/collections/SortWith.kt"
}

tasks.register("if_else", KonanLocalTest) {
    source = "codegen/branching/if_else.kt"
}

tasks.register("immutable_binary_blob_in_lambda", KonanLocalTest) {
    source = "lower/immutable_blob_in_lambda.kt"
    useGoldenData = true
}

tasks.register("when2", KonanLocalTest) {
    source = "codegen/branching/when2.kt"
}

tasks.register("when5", KonanLocalTest) {
    source = "codegen/branching/when5.kt"
}

tasks.register("when6", KonanLocalTest) {
    source = "codegen/branching/when6.kt"
}

tasks.register("when7", KonanLocalTest) {
    source = "codegen/branching/when7.kt"
}

tasks.register("when8", KonanLocalTest) {
    source = "codegen/branching/when8.kt"
    useGoldenData = true
}

tasks.register("when9", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/branching/when9.kt"
}

tasks.register("when_through", KonanLocalTest) {
    source = "codegen/branching/when_through.kt"
}

tasks.register("advanced_when2", KonanLocalTest) {
    source = "codegen/branching/advanced_when2.kt"
}

tasks.register("advanced_when5", KonanLocalTest) {
    source = "codegen/branching/advanced_when5.kt"
}

tasks.register("when_with_try1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/branching/when_with_try1.kt"
}

tasks.register("arraysForLoops", KonanLocalTest) {
    source = "codegen/bce/arraysForLoops.kt"
}

tasks.register("bool_yes", KonanLocalTest) {
    source = "codegen/function/boolean.kt"
}

tasks.register("named", KonanLocalTest) {
    source = "codegen/function/named.kt"
}


tasks.register("plus_eq", KonanLocalTest) {
    source = "codegen/function/plus_eq.kt"
}

tasks.register("minus_eq", KonanLocalTest) {
    source = "codegen/function/minus_eq.kt"
}

tasks.register("eqeq", KonanLocalTest) {
    source = "codegen/function/eqeq.kt"
}

tasks.register("function_referenceBigArity", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/function/referenceBigArity.kt"
}

tasks.register("cycle", KonanLocalTest) {
    source = "codegen/cycles/cycle.kt"
}

tasks.register("cycle_do", KonanLocalTest) {
    source = "codegen/cycles/cycle_do.kt"
}

tasks.register("cycle_for", KonanLocalTest) {
    source = "codegen/cycles/cycle_for.kt"
}

tasks.register("abstract_super", KonanLocalTest) {
    source = "datagen/rtti/abstract_super.kt"
}

tasks.register("vtable1", KonanLocalTest) {
    source = "datagen/rtti/vtable1.kt"
}

tasks.register("vtable_any", KonanLocalTest) {
    source = "datagen/rtti/vtable_any.kt"
    useGoldenData = true
}

tasks.register("strdedup1", KonanLocalTest) {
    useGoldenData = true
    source = "datagen/literals/strdedup1.kt"
}

tasks.register("strdedup2", KonanLocalTest) {
    // TODO: string deduplication across several components seems to require
    // linking them as bitcode modules before translating to machine code.
    enabled = false

    useGoldenData = true
    source = "datagen/literals/strdedup2.kt"
}

tasks.register("empty_string", KonanLocalTest) {
    useGoldenData = true
    source = "datagen/literals/empty_string.kt"
}

tasks.register("intrinsic", KonanLocalTest) {
    source = "codegen/function/intrinsic.kt"
}

//    Disabled until we extract the classes that should be
//    always present from stdlib into a separate binary.
//
//linkTest("link") {
//    useGoldenData = true
//    source = "link/src/bar.kt"
//    lib = "link/lib"
//}(

linkTest("link_omit_unused") {
    useGoldenData = true
    source = "link/omit/main.kt"
    lib = "link/omit/library.kt"
}

standaloneTest("link_default_libs") {
    useGoldenData = true
    source = "link/default/default.kt"
    UtilsKt.dependsOnPlatformLibs(it)
}

standaloneTest("link_testLib_explicitly1") {
    // there is no testLibrary for cross targets yet.
    enabled = project.target.name == project.hostName
    dependsOn installTestLib
    useGoldenData = true
    source = "link/testLib_explicitly1.kt"
    // We force library inclusion, so need to see the warning banner.
    flags = ['-l', 'testLibrary', '-r', testLibraryDir]
    doLast {
        def file = new File("$testLibraryDir/testLibrary")
        file.deleteDir()
    }
}

linkTest("no_purge_for_dependencies") {
    useGoldenData = true
    source = "link/purge1/prog.kt"
    lib = "link/purge1/lib.kt"
    UtilsKt.dependsOnPlatformLibs(it)
}

linkTest("lib@name") {
    useGoldenData = true
    source = "link/klib_name/prog.kt"
    lib = "link/klib_name/lib.kt"
}

tasks.register("for0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/basic/for0.kt"
}

tasks.register("throw0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/basic/throw0.kt"
}

tasks.register("statements0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/basic/statements0.kt"
}

standaloneTest("annotations0") {
    source = "codegen/annotations/annotations0.kt"
    flags = ['-tr']
}

tasks.register("boxing0", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/boxing/boxing0.kt"
}

tasks.register("boxing1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/boxing/boxing1.kt"
}

tasks.register("boxing2", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/boxing/boxing2.kt"
}

tasks.register("boxing3", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/boxing/boxing3.kt"
}

tasks.register("boxing4", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/boxing/boxing4.kt"
}

tasks.register("boxing5", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/boxing/boxing5.kt"
}

tasks.register("boxing6", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/boxing/boxing6.kt"
}

tasks.register("boxing7", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/boxing/boxing7.kt"
}

tasks.register("boxing8", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/boxing/boxing8.kt"
}

tasks.register("boxing9", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/boxing/boxing9.kt"
}

tasks.register("boxing10", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/boxing/boxing10.kt"
}

tasks.register("boxing11", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/boxing/boxing11.kt"
}

tasks.register("boxing12", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/boxing/boxing12.kt"
}

tasks.register("boxing13", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/boxing/boxing13.kt"
}

tasks.register("boxing14", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/boxing/boxing14.kt"
}

tasks.register("boxing15", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/boxing/boxing15.kt"
}

tasks.register("kt53100_casts", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/boxing/kt53100_casts.kt"
}

tasks.register("boxCache0", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/boxing/box_cache0.kt"
}

tasks.register("interface0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/basic/interface0.kt"
}

tasks.register("hash0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/basic/hash0.kt"
}

tasks.register("ieee754", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/basic/ieee754.kt"
}

standaloneTest("hypotenuse") {
    source = "runtime/basic/hypot.kt"
}

tasks.register("array_list1", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/collections/array_list1.kt"
}

tasks.register("array_list2", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/collections/array_list2.kt"
}

tasks.register("hash_map0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/collections/hash_map0.kt"
}

tasks.register("hash_map1", KonanLocalTest) {
    disabled = isAggressiveGC // TODO: Investigate why too slow
    useGoldenData = true
    source = "runtime/collections/hash_map1.kt"
}

tasks.register("hash_set0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/collections/hash_set0.kt"
}

tasks.register("listof0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/collections/listof0.kt"
}

tasks.register("listof1", KonanLocalTest) {
    enabled = false
    useGoldenData = true
    source = "datagen/literals/listof1.kt"
}


tasks.register("moderately_large_array", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/collections/moderately_large_array.kt"
}

tasks.register("moderately_large_array1", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/collections/moderately_large_array1.kt"
}

tasks.register("string_builder0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/text/string_builder0.kt"
}

tasks.register("string_builder1", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/text/string_builder1.kt"
}

tasks.register("string0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/text/string0.kt"
}

tasks.register("parse0", KonanLocalTest) {
    source = "runtime/text/parse0.kt"
}

tasks.register("to_string0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/text/to_string0.kt"
}

tasks.register("trim", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/text/trim.kt"
}

tasks.register("chars0", KonanLocalTest) {
    disabled = isAggressiveGC // TODO: Investigate why too slow
    source = "runtime/text/chars0.kt"
    expectedExitStatus = 0
}

tasks.register("indexof", KonanLocalTest) {
    source = "runtime/text/indexof.kt"
}

tasks.register("utf8", KonanLocalTest) {
    enabled = !isAggressiveGC // TODO: Investigate why too slow
    useGoldenData = true
    source = "runtime/text/utf8.kt"
}

tasks.register("catch1", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/exceptions/catch1.kt"
}

tasks.register("catch2", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/exceptions/catch2.kt"
}

tasks.register("catch7", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/exceptions/catch7.kt"
}

tasks.register("extend_exception", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/exceptions/extend0.kt"
}

standaloneTest("check_stacktrace_format_coresymbolication") {
    disabled = !supportsCoreSymbolication(project) || project.globalTestArgs.contains('-opt')
    flags = ['-g', '-Xbinary=sourceInfoType=coresymbolication']
    arguments = ['coresymbolication']
    source = "runtime/exceptions/check_stacktrace_format.kt"
}

standaloneTest("stack_trace_inline") {
    disabled = !supportsCoreSymbolication(project) || project.globalTestArgs.contains('-opt')
    flags = ['-g', '-Xg-generate-debug-trampoline=enable', '-Xbinary=sourceInfoType=coresymbolication']
    source = "runtime/exceptions/stack_trace_inline.kt"
    arguments = ['coresymbolication']
}

standaloneTest("kt-49240-stack-trace-completeness") {
    disabled = !supportsExceptions(project) || project.globalTestArgs.contains('-opt')
    source = "runtime/exceptions/kt-49240-stack-trace-completeness.kt"
}

standaloneTest("kt-37572") {
    disabled = !supportsCoreSymbolication(project) || project.globalTestArgs.contains('-opt')
    flags = ['-g', '-Xbinary=sourceInfoType=coresymbolication']
    arguments = ['coresymbolication']
    source = "runtime/exceptions/kt-37572.kt"
}

standaloneTest("check_stacktrace_format_libbacktrace") {
    disabled = !supportsLibBacktrace(project)|| project.globalTestArgs.contains('-opt')
    flags = ['-g', '-Xbinary=sourceInfoType=libbacktrace']
    arguments = ['libbacktrace']
    source = "runtime/exceptions/check_stacktrace_format.kt"
}

standaloneTest("stack_trace_inline_libbacktrace") {
    disabled = !supportsLibBacktrace(project) || project.globalTestArgs.contains('-opt')
    flags = ['-g', '-Xbinary=sourceInfoType=libbacktrace']
    arguments = ['libbacktrace']
    source = "runtime/exceptions/stack_trace_inline.kt"
}

standaloneTest("kt-37572-libbacktrace") {
    disabled = !supportsLibBacktrace(project) || project.globalTestArgs.contains('-opt')
    flags = ['-g', '-Xbinary=sourceInfoType=libbacktrace']
    arguments = ['libbacktrace']
    source = "runtime/exceptions/kt-37572.kt"
}

standaloneTest("except_constr_w_default") {
    disabled = !supportsLibBacktrace(project) || project.globalTestArgs.contains('-opt')
    flags = ['-g', '-Xbinary=sourceInfoType=libbacktrace']
    source = "runtime/exceptions/except_constr_w_default.kt"
}

standaloneTest("throw_from_except_constr") {
    disabled = !supportsLibBacktrace(project) || project.globalTestArgs.contains('-opt')
    flags = ['-g', '-Xbinary=sourceInfoType=libbacktrace']
    source = "runtime/exceptions/throw_from_except_constr.kt"
}

standaloneTest("custom_hook") {
    outputChecker = {
        it.contains("value 42: Error. Runnable state: true") && it.contains("Uncaught Kotlin exception: kotlin.Error: an error")
    }
    expectedExitStatusChecker = { it != 0 }
    source = "runtime/exceptions/custom_hook.kt"
    flags = ['-opt-in=kotlin.native.internal.InternalForKotlinNative']
}

standaloneTest("custom_hook_memory_leak") {
    outputChecker = {
        it.contains("Hook 42") && it.contains("Uncaught Kotlin exception: kotlin.Error: an error")
    }
    expectedExitStatusChecker = { it != 0 }
    source = "runtime/exceptions/custom_hook_memory_leak.kt"
}

standaloneTest("custom_hook_get") {
    source = "runtime/exceptions/custom_hook_get.kt"
}

standaloneTest("custom_hook_no_reset") {
    outputChecker = {
        it.contains("Hook called") && it.contains("Uncaught Kotlin exception: kotlin.Error: some error")
    }
    expectedExitStatusChecker = { it != 0 }
    source = "runtime/exceptions/custom_hook_no_reset.kt"
}

standaloneTest("custom_hook_throws") {
    outputChecker = {
        it.contains("Hook called") && it.contains("Uncaught Kotlin exception: kotlin.Error: another error") && !it.contains("some error")
    }
    expectedExitStatusChecker = { it != 0 }
    source = "runtime/exceptions/custom_hook_throws.kt"
}

standaloneTest("custom_hook_unhandled_exception") {
    useGoldenData = true
    source = "runtime/exceptions/custom_hook_unhandled_exception.kt"
}

standaloneTest("custom_hook_terminate") {
    outputChecker = {
        it.contains("Hook called")
    }
    expectedExitStatusChecker = { it != 0 }
    source = "runtime/exceptions/custom_hook_terminate.kt"
}

standaloneTest("custom_hook_terminate_unhandled_exception") {
    outputChecker = {
        it.contains("Hook called") && it.contains("Uncaught Kotlin exception: kotlin.Error: some error") && !it.contains("Not going to happen")
    }
    expectedExitStatusChecker = { it != 0 }
    source = "runtime/exceptions/custom_hook_terminate_unhandled_exception.kt"
}

standaloneTest("exception_in_global_init") {
    source = "runtime/exceptions/exception_in_global_init.kt"
    expectedExitStatusChecker = { it != 0 }
    outputChecker = { s -> s.contains("Uncaught Kotlin exception:") && s.contains("FAIL") && !s.contains("in kotlin main") }
}

tasks.register("rethrow_exception", KonanLocalTest) {
    source = "runtime/exceptions/rethrow.kt"
}

tasks.register("throw_from_catch", KonanLocalTest) {
    source = "runtime/exceptions/throw_from_catch.kt"
}

standaloneTest("terminate") {
    expectedExitStatusChecker = { it != 0 }
    source = "runtime/exceptions/terminate.kt"
}

standaloneTest("unhandled_exception") {
    outputChecker = {
        it.contains("Uncaught Kotlin exception: kotlin.Error: some error")
    }
    expectedExitStatusChecker = { it != 0 }
    source = "runtime/exceptions/unhandled_exception.kt"
}

standaloneTest("runtime_math_exceptions") {
    source = "stdlib_external/numbers/MathExceptionTest.kt"
    flags = ['-tr']
}

standaloneTest("runtime_math") {
    source = "stdlib_external/numbers/MathTest.kt"
    flags = ['-tr']
}

standaloneTest("runtime_math_harmony") {
    source = "stdlib_external/numbers/HarmonyMathTests.kt"
    flags = ['-tr']
}

tasks.register("catch3", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/catch3.kt"
}

tasks.register("catch4", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/catch4.kt"
}

tasks.register("catch5", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/catch5.kt"
}

tasks.register("catch6", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/catch6.kt"
}

tasks.register("catch8", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/catch8.kt"
}

tasks.register("finally1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/finally1.kt"
}

tasks.register("finally2", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/finally2.kt"
}

tasks.register("finally3", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/finally3.kt"
}

tasks.register("finally4", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/finally4.kt"
}

tasks.register("finally5", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/finally5.kt"
}

tasks.register("finally6", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/finally6.kt"
}

tasks.register("finally7", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/finally7.kt"
}

tasks.register("finally8", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/finally8.kt"
}

tasks.register("finally9", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/finally9.kt"
}

tasks.register("finally10", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/finally10.kt"
}

tasks.register("finally11", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/finally11.kt"
}

tasks.register("finally_returnsDifferentTypes", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/returnsDifferentTypes.kt"
}

tasks.register("scope1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/dataflow/scope1.kt"
}

tasks.register("uninitialized_val", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/dataflow/uninitialized_val.kt"
}

tasks.register("try1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/try1.kt"
}

tasks.register("try2", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/try2.kt"
}

tasks.register("try3", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/try3.kt"
}

tasks.register("try4", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/try/try4.kt"
}

tasks.register("unreachable1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/controlflow/unreachable1.kt"
}

tasks.register("break_continue", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/controlflow/break.kt"
}

tasks.register("break1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/controlflow/break1.kt"
}

tasks.register("range0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/collections/range0.kt"
}

standaloneTest("args0") {
    arguments = ["AAA", "BB", "C"]
    useGoldenData = true
    source = "runtime/basic/args0.kt"
}

standaloneTest("devirtualization_lateinitInterface") {
    disabled = (cacheTesting != null) // Cache is not compatible with -opt.
    useGoldenData = true
    flags = ["-opt"]
    source = "codegen/devirtualization/lateinitInterface.kt"
}

standaloneTest("devirtualization_getter_looking_as_box_function") {
    disabled = (cacheTesting != null) // Cache is not compatible with -opt.
    useGoldenData = true
    flags = ["-opt"]
    source = "codegen/devirtualization/getter_looking_as_box_function.kt"
}

standaloneTest("devirtualization_inline_getter") {
    disabled = (cacheTesting != null) // Cache is not compatible with -opt.
    useGoldenData = true
    flags = ["-opt"]
    source = "codegen/devirtualization/inline_getter.kt"
}


standaloneTest("devirtualization_anonymousObject") {
    disabled = (cacheTesting != null) // Cache is not compatible with -opt.
    useGoldenData = true
    flags = ["-opt"]
    source = "codegen/devirtualization/anonymousObject.kt"
}

tasks.register("interfaceCallsNCasts_conservativeItable", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/interfaceCallsNCasts/conservativeItable.kt"
}

tasks.register("interfaceCallsNCasts_functionNameClash", KonanLocalTest) {
    source = "codegen/interfaceCallsNCasts/functionNameClash.kt"
}

tasks.register("interfaceCallsNCasts_finalMethod", KonanLocalTest) {
    source = "codegen/interfaceCallsNCasts/finalMethod.kt"
}

tasks.register("interfaceCallsNCasts_diamond", KonanLocalTest) {
    source = "codegen/interfaceCallsNCasts/diamond.kt"
}

tasks.register("spread_operator_0", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/basics/spread_operator_0.kt"
}

tasks.register("main_exception", KonanLocalTest) {
    outputChecker = { s -> s.contains("kotlin.Error: Hello!") }
    expectedExitStatus = 1
    source = "runtime/basic/main_exception.kt"
}

tasks.register("runtime_basic_standard", KonanLocalTest) {
    source = "runtime/basic/standard.kt"
}

standaloneTest("runtime_basic_assert_failed") {
    expectedExitStatusChecker = { it != 0 }
    source = "runtime/basic/assert_failed.kt"
}

standaloneTest("runtime_basic_assert_passed") {
    expectedExitStatus = 0
    source = "runtime/basic/assert_passed.kt"
}

standaloneTest("runtime_basic_assert_disabled") {
    expectedExitStatus = 0
    enableKonanAssertions = false
    source = "runtime/basic/assert_failed.kt"
}

tasks.register("initializers0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/basic/initializers0.kt"
}


tasks.register("initializers1", KonanLocalTest) {
    useGoldenData = true
    enabled = false
    source = "runtime/basic/initializers1.kt"
}


tasks.register("concatenation", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/basics/concatenation.kt"
}

tasks.register("const_infinity", KonanLocalTest) {
    source = "codegen/basics/const_infinity.kt"
}

tasks.register("lambda1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lambda/lambda1.kt"
}

tasks.register("lambda2", KonanLocalTest) {
    arguments = ["arg0"]
    useGoldenData = true
    source = "codegen/lambda/lambda2.kt"
}

tasks.register("lambda3", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lambda/lambda3.kt"
}

tasks.register("lambda4", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lambda/lambda4.kt"
}

tasks.register("lambda5", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lambda/lambda5.kt"
}

tasks.register("lambda6", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lambda/lambda6.kt"
}

tasks.register("lambda7", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lambda/lambda7.kt"
}

tasks.register("lambda8", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lambda/lambda8.kt"
}

tasks.register("lambda9", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lambda/lambda9.kt"
}

tasks.register("lambda10", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lambda/lambda10.kt"
}

tasks.register("lambda11", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lambda/lambda11.kt"
}

tasks.register("lambda12", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lambda/lambda12.kt"
}

tasks.register("lambda13", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/lambda/lambda13.kt"
}

standaloneTest("lambda14") {
    source = "codegen/lambda/lambda14.kt"
    flags = ['-tr']
}

tasks.register("lambda_kt49360", KonanLocalTest) {
    source = "codegen/lambda/lambda_kt49360.kt"
}

tasks.register("funInterface_implIsNotFunction", KonanLocalTest) {
    source = "codegen/funInterface/implIsNotFunction.kt"
}

tasks.register("funInterface_nonTrivialProjectionInSuperType", KonanLocalTest) {
    source = "codegen/funInterface/nonTrivialProjectionInSuperType.kt"
}

tasks.register("funInterface_kt43887", KonanLocalTest) {
    source = "codegen/funInterface/kt43887.kt"
}

tasks.register("funInterface_kt49384", KonanLocalTest) {
    source = "codegen/funInterface/kt49384.kt"
}

tasks.register("objectExpression1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/objectExpression/expr1.kt"
}

tasks.register("objectExpression2", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/objectExpression/expr2.kt"
}

tasks.register("objectExpression3", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/objectExpression/expr3.kt"
}

standaloneTest("initializers2") {
    useGoldenData = true

    source = "runtime/basic/initializers2.kt"
}

tasks.register("initializers3", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/basic/initializers3.kt"
}

tasks.register("initializers4", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/basic/initializers4.kt"
}

tasks.register("initializers5", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/basic/initializers5.kt"
}

tasks.register("initializers6", KonanLocalTest) {
    source = "runtime/basic/initializers6.kt"
}

tasks.register("initializers7", KonanLocalTest) {
    source = "runtime/basic/initializers7.kt"
}

tasks.register("initializers8", KonanLocalTest) {
    source = "runtime/basic/initializers8.kt"
}

tasks.register("expression_as_statement", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/basics/expression_as_statement.kt"
}

tasks.register("codegen_escapeAnalysis_zeroOutObjectOnAlloc", KonanLocalTest) {
    source = "codegen/escapeAnalysis/zeroOutObjectOnAlloc.kt"
}

tasks.register("codegen_escapeAnalysis_recursion", KonanLocalTest) {
    source = "codegen/escapeAnalysis/recursion.kt"
}

standaloneTest("codegen_escapeAnalysis_stackAllocated") {
    disabled = (cacheTesting != null) || // Cache is not compatible with -opt.
        project.globalTestArgs.contains('-g') // -g and -opt are incompatible
    flags = ['-opt', '-tr', '-opt-in=kotlin.native.internal.InternalForKotlinNative']
    source = "codegen/escapeAnalysis/stackAllocated.kt"
}

standaloneTest("codegen_escapeAnalysis_string") {
    disabled = (cacheTesting != null) || // Cache is not compatible with -opt.
        project.globalTestArgs.contains('-g') // -g and -opt are incompatible
    flags = ['-opt', '-tr', '-opt-in=kotlin.native.internal.InternalForKotlinNative']
    source = "codegen/escapeAnalysis/string.kt"
}

standaloneTest("codegen_escapeAnalysis_negativeArraySize") {
    disabled = (cacheTesting != null) || // Cache is not compatible with -opt.
            project.globalTestArgs.contains('-g') // -g and -opt are incompatible
    flags = ['-opt', '-tr', '-opt-in=kotlin.native.internal.InternalForKotlinNative']
    source = "codegen/escapeAnalysis/negativeArraySize.kt"
}

tasks.register("memory_var1", KonanLocalTest) {
    source = "runtime/memory/var1.kt"
}

tasks.register("memory_var2", KonanLocalTest) {
    source = "runtime/memory/var2.kt"
}

tasks.register("memory_var3", KonanLocalTest) {
    source = "runtime/memory/var3.kt"
}

tasks.register("memory_var4", KonanLocalTest) {
    source = "runtime/memory/var4.kt"
}

tasks.register("memory_throw_cleanup", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/memory/throw_cleanup.kt"
}

tasks.register("memory_escape0", KonanLocalTest) {
    source = "runtime/memory/escape0.kt"
}

tasks.register("memory_escape1", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/memory/escape1.kt"
}

tasks.register("memory_cycles0", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/memory/cycles0.kt"
}

tasks.register("memory_cycles1", KonanLocalTest) {
    enabled = !isNoopGC
    source = "runtime/memory/cycles1.kt"
}

tasks.register("memory_basic0", KonanLocalTest) {
    source = "runtime/memory/basic0.kt"
}

tasks.register("memory_escape2", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/memory/escape2.kt"
}

tasks.register("memory_weak0", KonanLocalTest) {
    enabled = !isNoopGC
    useGoldenData = true
    source = "runtime/memory/weak0.kt"
}

tasks.register("memory_weak1", KonanLocalTest) {
    useGoldenData = true
    source = "runtime/memory/weak1.kt"
}

standaloneTest("memory_only_gc") {
    source = "runtime/memory/only_gc.kt"
}

tasks.register("memory_stable_ref_cross_thread_check", KonanLocalTest) {
    source = "runtime/memory/stable_ref_cross_thread_check.kt"
}

standaloneTest("leakMemory") {
    source = "runtime/memory/leak_memory.kt"
}

standaloneTest("leakMemoryWithTestRunner") {
    source = "runtime/memory/leak_memory_test_runner.kt"
    flags = ['-tr']
}

standaloneTest("gcStats") {
    source = "runtime/memory/gcStats.kt"
    flags = ['-tr', "-Xbinary=gcSchedulerType=disabled"]
    enabled = !isNoopGC && !isAggressiveGC
}

standaloneTest("stress_gc_allocations") {
    // TODO: Support obtaining peak RSS on more platforms.
    enabled =
        (project.testTarget != "watchos_arm32") &&
        (project.testTarget != "watchos_arm64") &&
        (project.testTarget != "watchos_x86") &&
        (project.testTarget != "watchos_x64") &&
        (project.testTarget != "watchos_simulator_arm64") &&
        !isNoopGC &&
        !isAggressiveGC && // TODO: Investigate why too slow
        !runtimeAssertionsPanic && // New allocator with assertions makes this test very slow
        (project.testTarget != "mingw_x64") // TODO: Fix on mingw.
    source = "runtime/memory/stress_gc_allocations.kt"
    flags = ['-tr', '-opt-in=kotlin.native.internal.InternalForKotlinNative']
}

standaloneTest("array_out_of_memory") {
    source = "runtime/memory/array_out_of_memory.kt"
    flags = ['-tr']
    switch(project.target.architecture) {
        case Architecture.X64:
        case Architecture.ARM64:
            break;
        case Architecture.X86:
        case Architecture.ARM32:
        case Architecture.MIPS32:
        case Architecture.MIPSEL32:
        case Architecture.WASM32:
            expectedExitStatusChecker = { it != 0 }
            outputChecker = { s -> s.contains("Out of memory trying to allocate") }
            break;
    }
}

tasks.register("unit1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/basics/unit1.kt"
}

tasks.register("unit2", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/basics/unit2.kt"
}

tasks.register("unit3", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/basics/unit3.kt"
}

tasks.register("unit4", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/basics/unit4.kt"
}

tasks.register("kt42000_1", KonanLocalTest) {
    source = "codegen/basics/k42000_1.kt"
}

tasks.register("kt42000_2", KonanLocalTest) {
    source = "codegen/basics/k42000_2.kt"
}

tasks.register("inline0", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline0.kt"
}

tasks.register("vararg0", KonanLocalTest) {
    source = "lower/vararg.kt"
}

tasks.register("vararg_of_literals", KonanLocalTest) {
    enabled = false
    useGoldenData = true
    source = "lower/vararg_of_literals.kt"
}

standaloneTest('tailrec') {
    disabled = isAggressiveGC || // TODO: Investigate why too slow
            isK2(project) // KT-56269
    useGoldenData = true
    source = "lower/tailrec.kt"
    flags = ['-XXLanguage:-ProhibitTailrecOnVirtualMember', '-e', 'lower.tailrec.main']
}

tasks.register("inline1", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline1.kt"
}

tasks.register("inline2", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline2.kt"
}

tasks.register("inline3", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline3.kt"
}

tasks.register("inline4", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline4.kt"
}

tasks.register("inline5", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline5.kt"
}

tasks.register("inline6", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline6.kt"
}

tasks.register("inline7", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline7.kt"
}

tasks.register("inline8", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline8.kt"
}

tasks.register("inline9", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline9.kt"
}

tasks.register("inline10", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline10.kt"
}

tasks.register("inline13", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline13.kt"
}

tasks.register("inline14", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline14.kt"
}

tasks.register("inline15", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline15.kt"
}

tasks.register("inline16", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline16.kt"
}

tasks.register("inline17", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline17.kt"
}

tasks.register("inline18", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline18.kt"
}

tasks.register("inline19", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline19.kt"
}

tasks.register("inline20", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline20.kt"
}

tasks.register("inline21", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline21.kt"
}

tasks.register("inline22", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline22.kt"
}

tasks.register("inline23", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline23.kt"
}

tasks.register("inline24", KonanLocalTest) {
    enabled = false
    useGoldenData = true
    source = "codegen/inline/inline24.kt"
}

tasks.register("inline25", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline25.kt"
}

tasks.register("inline26", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/inline26.kt"
}

tasks.register("inline_type_substitution_in_fake_override", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/typeSubstitutionInFakeOverride.kt"
}

tasks.register("inline_localFunctionInInitializerBlock", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/localFunctionInInitializerBlock.kt"
}

tasks.register("inline_lambdaInDefaultValue", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/lambdaInDefaultValue.kt"
}

tasks.register("inline_lambdaAsAny", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/lambdaAsAny.kt"
}

tasks.register("inline_getClass", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/getClass.kt"
}

tasks.register("inline_statementAsLastExprInBlock", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/statementAsLastExprInBlock.kt"
}

tasks.register("inline_returnLocalClassFromBlock", KonanLocalTest) {
    enabled = false
    useGoldenData = true
    source = "codegen/inline/returnLocalClassFromBlock.kt"
}

tasks.register("inline_changingCapturedLocal", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/changingCapturedLocal.kt"
}

tasks.register("inline_defaultArgs", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/defaultArgs.kt"
}

tasks.register("inline_propertyAccessorInline", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/propertyAccessorInline.kt"
}

tasks.register("inline_twiceInlinedObject", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/twiceInlinedObject.kt"
}

tasks.register("inline_localObjectReturnedFromWhen", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/localObjectReturnedFromWhen.kt"
}

tasks.register("inline_genericFunctionReference", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/genericFunctionReference.kt"
}

tasks.register("inline_correctOrderFunctionReference", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/correctOrderFunctionReference.kt"
}

tasks.register("inline_coercionToUnit", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/inline/coercionToUnit.kt"
}

tasks.register("inline_redundantCoercionsCleaner", KonanLocalTest) {
    source = "codegen/inline/redundantCoercionsCleaner.kt"
}

tasks.register("classDeclarationInsideInline", KonanLocalTest) {
    source = "codegen/inline/classDeclarationInsideInline.kt"
    useGoldenData = true
}

tasks.register("inlineClass0", KonanLocalTest) {
    source = "codegen/inlineClass/inlineClass0.kt"
}

tasks.register("inlineClass_customEquals", KonanLocalTest) {
    source = "codegen/inlineClass/customEquals.kt"
}

tasks.register("inlineClass_defaultEquals", KonanLocalTest) {
    source = "codegen/inlineClass/defaultEquals.kt"
}

tasks.register("inlineClass_secondaryConstructorWithGenerics", KonanLocalTest) {
    source = "codegen/inlineClass/secondaryConstructorWithGenerics.kt"
}

tasks.register("inlineClass_nestedInlineClasses", KonanLocalTest) {
    source = "codegen/inlineClass/nestedInlineClasses.kt"
}

tasks.register("valueClass0", KonanLocalTest) {
    source = "codegen/inlineClass/valueClass0.kt"
}

tasks.register("deserialized_inline0", KonanLocalTest) {
    source = "serialization/deserialized_inline0.kt"
}

tasks.register("deserialized_listof0", KonanLocalTest) {
    source = "serialization/deserialized_listof0.kt"
}

tasks.register("deserialized_fields", KonanLocalTest) {
    source = "serialization/deserialized_fields.kt"
}

KotlinNativeTestKt.createTest(project, "kt39548", KonanStandaloneTest) { task ->
    // Test infrastructure doesn't support generated source;
    // workaround by specifying dummy source:
    task.source = "does/not/exist/kt39548.dummy.kt"
    task.enabled = isWindowsTarget(project)

    if (task.enabled) {
        konanArtifacts {
            program(name, targets: [target.name]) {
                baseDir   "$testOutputLocal/$name"
                srcFiles  "$buildDir/kt39548/kt39548.kt" // Generated by doBeforeBuild task.
                extraOpts task.flags
                extraOpts project.globalTestArgs
            }
        }
        doBeforeBuild {
            GenTestKT39548Kt.genTestKT39548(file("$buildDir/kt39548/kt39548.kt"))
        }
    }
}

linkTest("deserialized_members") {
    source = "serialization/deserialized_members/main.kt"
    lib = "serialization/deserialized_members/library.kt"
    useGoldenData = true
}

linkTest("serialized_catch") {
    source = "serialization/serialized_catch/main.kt"
    lib = "serialization/serialized_catch/library.kt"
    useGoldenData = true
}

linkTest("serialized_doWhile") {
    source = "serialization/serialized_doWhile/main.kt"
    lib = "serialization/serialized_doWhile/library.kt"
    useGoldenData = true
}

linkTest("serialized_vararg") {
    source = "serialization/serialized_vararg/main.kt"
    lib = "serialization/serialized_vararg/library.kt"
    useGoldenData = true
}

linkTest("serialized_default_args") {
    source = "serialization/serialized_default_args/main.kt"
    lib = "serialization/serialized_default_args/library.kt"
    useGoldenData = true
}

standaloneTest("serialized_no_typemap") {
    source = "serialization/regression/no_type_map.kt"
    useGoldenData = true
}

linkTest("serialized_enum_ordinal") {
    source = "serialization/enum_ordinal/main.kt"
    lib = "serialization/enum_ordinal/library.kt"
    useGoldenData = true
}

linkTest("serialized_char_constant") {
    source = "serialization/serialized_char_constant/main.kt"
    lib = "serialization/serialized_char_constant/library.kt"
    useGoldenData = true
}

standaloneTest("testing_annotations") {
    source = "testing/annotations.kt"
    flags = ['-tr']
    arguments = ['--ktest_logger=SIMPLE']
    useGoldenData = true
}

standaloneTest("testing_assertions") {
    source = "testing/assertions.kt"
    flags = ['-tr']
    expectedExitStatus = 0
}

standaloneTest("testing_custom_main") {
    source = "testing/custom_main.kt"
    flags = ['-tr', '-e', 'kotlin.test.tests.main']
    arguments = ['--ktest_logger=SIMPLE', '--ktest_repeat=2']
    useGoldenData = true
}

standaloneTest("testing_library_usage") {
    def target = project.testTarget ?: 'host'
    dependsOn konanArtifacts.baseTestClass.getByTarget(target)
    def klib = konanArtifacts.baseTestClass.getArtifactByTarget(target)
    source = 'testing/library_user.kt'
    flags = ['-tr', '-e', 'main', '-l', klib.absolutePath]
    arguments = ['--ktest_logger=SILENT']
}

class Filter {
    List<String> positive
    List<String> negative
    List<String> expectedTests

    Filter(List<String> positive, List<String> negative, List<String> expectedTests) {
        this.positive = positive
        this.negative = negative
        this.expectedTests = expectedTests
    }

    List<String> args() {
        List<String> result = []
        if (positive != null && !positive.isEmpty()) {
            result += "--ktest_gradle_filter=${asListOfPatterns(positive)}"
        }
        if (negative != null && !negative.isEmpty()) {
            result += "--ktest_negative_gradle_filter=${asListOfPatterns(negative)}"
        }
        return result
    }

    static private String asListOfPatterns(List<String> input) {
        return input.collect { "kotlin.test.tests.$it" }.join(",")
    }
}

standaloneTest("testing_filters") {
    source = "testing/filters.kt"
    flags = ['-tr', '-ea']
    def filters = [
        new Filter(["A.foo1", "B", "FiltersKt.foo1"], [], ["A.foo1", "B.foo1", "B.foo2", "B.bar", "FiltersKt.foo1"]),
        new Filter([], ["A.foo1", "B", "FiltersKt.foo1"], ["A.foo2", "A.bar", "FiltersKt.foo2", "FiltersKt.bar"]),
        new Filter(["A", "FiltersKt"], ["A.foo1", "FiltersKt.foo1"], ["A.foo2", "A.bar", "FiltersKt.foo2", "FiltersKt.bar"]),
        new Filter(["A.foo*", "B.*"], [], ["A.foo1", "A.foo2", "B.foo1", "B.foo2", "B.bar"]),
        new Filter([], ["A.foo*", "B.*"], ["A.bar", "FiltersKt.foo1", "FiltersKt.foo2", "FiltersKt.bar"]),
        new Filter(["*.foo*"], ["B"], ["A.foo1", "A.foo2", "FiltersKt.foo1", "FiltersKt.foo2"]),
        new Filter(["A"], ["*.foo*"], ["A.bar"])
    ]
    multiRuns = true
    multiArguments = filters.collect { it.args() + '--ktest_logger=SIMPLE' }
    outputChecker = { String output ->
        // The first chunk is empty - drop it.
        def outputs = output.split("Starting testing\n").drop(1)
        if (outputs.size() != filters.size()) {
            println("Incorrect number of test runs. Expected: ${filters.size()}, actual: ${outputs.size()}")
            return false
        }

        // Check the correct set of tests was executed in each run.
        for (int i = 0; i < outputs.size(); i++) {
            def actualMessages = outputs[i].split('\n').findAll { it.startsWith("Passed: ") }
            def expectedMessages = filters[i].expectedTests.collect { String test ->
                def method = test.substring(test.lastIndexOf('.') + 1)
                def suite = test.substring(0, test.lastIndexOf('.'))
                "Passed: $method (kotlin.test.tests.$suite)".toString()
            }

            if (actualMessages.size() != expectedMessages.size()) {
                println("Incorrect number of tests executed for filters[$i]. Expected: ${expectedMessages.size()}. Actual: ${actualMessages.size()}")
                return false
            }

            for (message in expectedMessages) {
                if (!actualMessages.contains(message)) {
                    println("Test run output for filters[$i] doesn't contain the expected message '$message'")
                    return false
                }
            }
        }
        return true
    }
}

standaloneTest("testing_filtered_suites") {
    source = "testing/filtered_suites.kt"
    flags = ["-tr", "-ea"]

    def filters = [
            ["Filtered_suitesKt.*"],    // filter out a class.
            ["A.*"],                    // filter out a top-level suite.
            ["*.common"],               // run a test from all suites -> all hooks executed.
            ["Ignored.*"],              // an ignored suite -> no hooks executed.
            ["A.ignored"]               // a suite with only ignored tests -> no hooks executed.
    ]
    def expectedHooks = [
            ["Filtered_suitesKt.before", "Filtered_suitesKt.after"],
            ["A.before", "A.after"],
            ["A.before", "A.after", "Filtered_suitesKt.before", "Filtered_suitesKt.after"],
            [],
            []
    ]

    multiRuns = true
    multiArguments = filters.collect {
        def filter = it.collect { "kotlin.test.tests.$it" }.join(",")
        ["--ktest_gradle_filter=$filter", "--ktest_logger=SIMPLE"]
    }
    outputChecker = { String output ->
        // The first chunk is empty - drop it.
        def outputs = output.split("Starting testing\n").drop(1)
        if (outputs.size() != expectedHooks.size()) {
            println("Incorrect number of test runs. Expected: ${expectedHooks.size()}, actual: ${outputs.size()}")
            return false
        }

        // Check the correct set of hooks was executed on each run.
        for (int i = 0; i < outputs.size(); i++) {
            def actual = outputs[i].split('\n')
                    .findAll { it.startsWith("Hook:") }
                    .collect { it.replace("Hook: ", "") }
            def expected = expectedHooks[i]

            if (actual.size() != expected.size()) {
                println("Incorrect number of executed hooks for run #$i. Expected: ${expected.size()}. Actual: ${actual.size()}")
                println("Expected hooks: $expected")
                println("Actual hooks: $actual")
                return false
            }

            for (expectedHook in expected) {
                if (!actual.contains(expectedHook)) {
                    println("Expected hook wasn't executed for run #$i: $expectedHook")
                    println("Expected hooks: $expected")
                    println("Actual hooks: $actual")
                    return false
                }
            }
        }
        return true
    }
}

// Check that stacktraces and ignored suite are correctly reported in the TC logger.
standaloneTest("testing_stacktrace") {
    source = "testing/stacktrace.kt"
    flags = ['-tr', '-ea']
    arguments = ["--ktest_logger=TEAMCITY", "--ktest_no_exit_code"]
    // This test prints TeamCity service messages about failed test causing false negative failure at CI.
    // So we need to suppress printing these messages to stdout.
//    printOutput = false
    outputChecker = { String output ->
        def ignoredOutput = """\
            |##teamcity[testSuiteStarted name='kotlin.test.tests.Ignored' locationHint='ktest:suite://kotlin.test.tests.Ignored']
            |##teamcity[testIgnored name='foo']
            |##teamcity[testSuiteFinished name='kotlin.test.tests.Ignored']""".stripMargin()
        def failedOutput = """\
            |##teamcity[testSuiteStarted name='kotlin.test.tests.Failed' locationHint='ktest:suite://kotlin.test.tests.Failed']
            |##teamcity[testStarted name='bar' locationHint='ktest:test://kotlin.test.tests.Failed.bar']
            |##teamcity[testFailed name='bar' message='Bar' details='kotlin.Exception: Bar|n""".stripMargin()

        def shownInnerException = output.readLines()
                .find { it.startsWith("##teamcity[testFailed name='bar'") }
                ?.contains("Caused by: kotlin.Exception: Baz") ?: false

        return output.contains(ignoredOutput) && output.contains(failedOutput) && shownInnerException
    }
}

// Just check that the driver is able to produce runnable binaries.
tasks.register("driver0", KonanDriverTest) {
    disabled = isAggressiveGC // No need to test with different GC schedulers
    useGoldenData = true
    source = "runtime/basic/driver0.kt"
}

tasks.register("driver_opt", KonanDriverTest) {
    disabled = (cacheTesting != null) // Cache is not compatible with -opt.
        || isAggressiveGC // No need to test with different GC schedulers
    useGoldenData = true
    source = "runtime/basic/driver_opt.kt"
    flags = ["-opt"]
}

// Enable when deserialization for default arguments is fixed.
linkTest("inline_defaultArgs_linkTest") {
    useGoldenData = true
    source = "codegen/inline/defaultArgs_linkTest_main.kt"
    lib = "codegen/inline/defaultArgs_linkTest_lib.kt"
}

linkTest("inline_sharedVar_linkTest") {
    useGoldenData = true
    source = "codegen/inline/sharedVar_linkTest_main.kt"
    lib = "codegen/inline/sharedVar_linkTest_lib.kt"
}

linkTest("inline_lateinitProperty_linkTest") {
    useGoldenData = true
    source = "codegen/inline/lateinitProperty_linkTest_main.kt"
    lib = "codegen/inline/lateinitProperty_linkTest_lib.kt"
}

linkTest("inline_inlineCtor_linkTest") {
    source = "codegen/inline/inlineCtor_linkTest_main.kt"
    lib = "codegen/inline/inlineCtor_linkTest_lib.kt"
}

linkTest("inline_innerInlineFunCapturesOuter_linkTest") {
    useGoldenData = true
    source = "codegen/inline/innerInlineFunCapturesOuter_linkTest_main.kt"
    lib = "codegen/inline/innerInlineFunCapturesOuter_linkTest_lib.kt"
}

def generateWithSpaceDefFile() {
    def mapOption = "--Map \"${buildDir}/cutom map.map\""
    if (isAppleTarget(project)) {
        mapOption = "-map \"${buildDir}/cutom map.map\""
    } else if (isWindowsTarget(project)) {
        mapOption = "\"-Wl,--Map,${buildDir}/cutom map.map\""
    }

    buildDir.mkdirs()
    def file = new File("${buildDir}/withSpaces.def")
    file.write """
headers = stdio.h "${projectDir}/interop/basics/custom headers/custom.h"
linkerOpts = $mapOption
---

int customCompare(const char* str1, const char* str2) {
    return custom_strcmp(str1, str2);
}
"""
    return file.absolutePath
}

// A helper method to create interop artifacts
void createInterop(String name, Closure conf) {
    konanArtifacts {
        interop(name, targets: [target.name]) {
            conf(it)
            noDefaultLibs(true)
            noEndorsedLibs(true)
            baseDir "$testOutputLocal/$name"
        }
    }
}

createInterop("sysstat") {
    // FIXME: creates empty file to workaround konan gradle plugin issue (should be able to have no def file)
    def f = File.createTempFile("sysstat.empty", ".def")
    it.packageName 'sysstat'
    // FIXME: this option doesn't work due to an issue in plugin: it tries to resolve header in project dir.
    //it.headers 'sys/stat.h'
    f.write("headers = sys/stat.h")
    it.defFile f
}

createInterop("cstdlib") {
    it.defFile 'interop/basics/cstdlib.def'
}

createInterop("cstdio") {
    it.defFile 'interop/basics/cstdio.def'
}

createInterop("sockets") {
    it.defFile 'interop/basics/sockets.def'
}

createInterop("bitfields") {
    it.defFile 'interop/basics/bitfields.def'
}

createInterop("cglobals") {
    it.defFile 'interop/basics/cglobals.def'
}

createInterop("cfunptr") {
    it.defFile 'interop/basics/cfunptr.def'
}

createInterop("cmacros") {
    it.defFile 'interop/basics/cmacros.def'
}

createInterop("cunsupported") {
    it.defFile 'interop/basics/cunsupported.def'
}

createInterop("ctoKString") {
    it.defFile 'interop/basics/ctoKString.def'
}

createInterop("ctypes") {
    it.defFile 'interop/basics/ctypes.def'
}

createInterop("structAnonym") {
    it.defFile 'interop/basics/structAnonym.def'
}

createInterop("cvalues") {
    it.defFile 'interop/basics/cvalues.def'
}

createInterop("cvectors") {
    it.defFile 'interop/basics/cvectors.def'
}

createInterop("cstructs") {
    it.defFile 'interop/basics/cstructs.def'
}

createInterop("ccallbacksAndVarargs") {
    it.defFile 'interop/basics/ccallbacksAndVarargs.def'
}

createInterop("cmangling") {
    it.defFile 'interop/basics/mangling.def'
}

createInterop("cmangling2") {
    it.defFile 'interop/basics/mangling2.def'
}

createInterop("cmangling_keywords") {
    it.defFile 'interop/basics/mangling_keywords.def'
}

createInterop("cmangling_keywords2") {
    it.defFile 'interop/basics/mangling_keywords2.def'
}

createInterop("cunion") {
    it.defFile 'interop/basics/cunion.def'
}

createInterop("cenums") {
    it.defFile 'interop/basics/cenums.def'
}

createInterop("carrayPointers") {
    it.defFile 'interop/basics/carrayPointers.def'
}

createInterop("auxiliaryCppSources") {
    // We need to provide empty def file to create correct `KonanInteropTask`.
    it.defFile 'interop/auxiliary_sources/auxiliaryCppSources.def'
    it.headers "$projectDir/interop/auxiliary_sources/name.h"
    it.extraOpts "-Xcompile-source", "$projectDir/interop/auxiliary_sources/name.cpp"
    it.extraOpts "-Xsource-compiler-option", "-std=c++17"
}

createInterop("concurrentTerminate") {
    it.defFile 'interop/concurrentTerminate/concurrentTerminate.def'
    it.headers "$projectDir/interop/concurrentTerminate/async.h"
    // TODO: Using `-Xcompile-source` does not imply dependency on that source, so the task will no re-run when the source is updated.
    it.extraOpts "-Xcompile-source", "$projectDir/interop/concurrentTerminate/async.cpp"
    it.extraOpts "-Xsource-compiler-option", "-std=c++17"
}

createInterop("incomplete_types") {
    it.defFile 'interop/incomplete_types/library.def'
    it.headers "$projectDir/interop/incomplete_types/library.h"
    it.extraOpts "-Xcompile-source", "$projectDir/interop/incomplete_types/library.cpp"
}

createInterop("embedStaticLibraries") {
    it.defFile 'interop/embedStaticLibraries/embedStaticLibraries.def'
    it.headers "$projectDir/interop/embedStaticLibraries/embedStaticLibraries.h"

    // Note: also hardcoded in def file.
    final String libDir = "$buildDir/embedStaticLibraries/"

    it.getByTarget(target.name).configure {
        doFirst {
            1.upto(4) {
                UtilsKt.buildStaticLibrary(
                        project,
                        [file("$projectDir/interop/embedStaticLibraries/${it}.c")],
                        file("$libDir/${it}.a"),
                        file("$libDir/${it}.objs"),
                )
            }
        }
    }

    it.extraOpts '-staticLibrary', "1.a"
    it.extraOpts '-staticLibrary', "2.a"
}

createInterop("kt43265") {
    it.defFile 'interop/kt43265/kt43265.def'
}

createInterop("kt44283") {
    it.defFile 'interop/kt44283/kt44283.def'
}

createInterop("kt51925") {
    it.defFile 'interop/kt51925/kt51925.def'
}

createInterop("kt54284") {
    it.defFile 'interop/kt54284/kt54284.def'
}

createInterop("kt54284_fmodules") {
    it.defFile 'interop/kt54284/kt54284.def'
    it.extraOpts '-compiler-option', '-fmodules'
}

createInterop("kt43502") {
    it.defFile 'interop/kt43502/kt43502.def'
    it.headers "$projectDir/interop/kt43502/kt43502.h"
    // Note: also hardcoded in def file.
    final String libDir = "$buildDir/kt43502/"
    // Construct library that contains actual symbol definition.
    it.getByTarget(target.name).configure {
        doFirst {
            UtilsKt.buildStaticLibrary(
                    project,
                    [file("$projectDir/interop/kt43502/kt43502.c")],
                    file("$libDir/kt43502.a"),
                    file("$libDir/kt43502.objs"),
            )
        }
    }
}

createInterop("leakMemoryWithRunningThread") {
    it.defFile 'interop/leakMemoryWithRunningThread/leakMemory.def'
    it.headers "$projectDir/interop/leakMemoryWithRunningThread/leakMemory.h"
    it.extraOpts "-Xcompile-source", "$projectDir/interop/leakMemoryWithRunningThread/leakMemory.cpp"
}

createInterop("cppClass") {
    it.defFile 'interop/cpp/cppClass.def'
}

createInterop("cppTypes") {
    it.defFile 'interop/cpp/types.def'
}

createInterop("cppSkia") {
    it.defFile 'interop/cpp/skia.def'
}

createInterop("cppSkiaSignature") {
    it.defFile 'interop/cpp/skiaSignature.def'
}

createInterop("threadStates") {
    it.defFile "interop/threadStates/threadStates.def"
    it.extraOpts "-Xcompile-source", "$projectDir/interop/threadStates/threadStates.cpp"
}

createInterop("workerSignals") {
    it.defFile "interop/workerSignals/workerSignals.def"
    it.headers "$projectDir/interop/workerSignals/workerSignals.h"
    it.extraOpts "-Xcompile-source", "$projectDir/interop/workerSignals/workerSignals.cpp"
}

createInterop("cForwardDeclarations") {
    it.defFile "interop/forwardDeclarations/cForwardDeclarations.def"
}

createInterop("cForwardDeclarationsTwoLibs1") {
    it.defFile "interop/forwardDeclarationsTwoLibs/cForwardDeclarationsTwoLibs1.def"
}

createInterop("cForwardDeclarationsTwoLibs2") {
    it.defFile "interop/forwardDeclarationsTwoLibs/cForwardDeclarationsTwoLibs2.def"
}

if (PlatformInfo.isAppleTarget(project)) {
    createInterop("forwardDeclarationsCastA") {
        it.defFile "interop/forwardDeclarationsCast/a.def"
    }

    createInterop("forwardDeclarationsCastB") {
        it.defFile "interop/forwardDeclarationsCast/b.def"
        it.headers "$projectDir/interop/forwardDeclarationsCast/b.h"
        it.extraOpts "-Xcompile-source", "$projectDir/interop/forwardDeclarationsCast/b.m"
    }

    createInterop("objcSmoke") {
        it.defFile 'interop/objc/objcSmoke.def'
        it.headers "$projectDir/interop/objc/smoke.h"
    }

    createInterop("objcTests") {
        it.defFile 'interop/objc/objcTests.def'
        it.headers fileTree("$projectDir/interop/objc/tests") { include '**/*.h' }
    }

    createInterop("objcMisc") {
        it.defFile 'interop/objc_with_initializer/objc_misc.def'
        it.headers "$projectDir/interop/objc_with_initializer/objc_misc.h"
    }

    createInterop("objcMessaging") {
        it.defFile 'interop/objc/msg_send/messaging.def'
        it.headers "$projectDir/interop/objc/msg_send/messaging.h"
    }

    createInterop("objcDirect") {
        it.defFile 'interop/objc/direct/direct.def'
        it.headers "$projectDir/interop/objc/direct/direct.h"
        it.extraOpts "-Xcompile-source", "$projectDir/interop/objc/direct/direct.m", "-Xsource-compiler-option", "-DNS_FORMAT_ARGUMENT(A)="
        it.compilerOpts '-DNS_FORMAT_ARGUMENT(A)='
    }

    createInterop("foreignException") {
        it.defFile 'interop/objc/foreignException/objc_wrap.def'
        it.headers "$projectDir/interop/objc/foreignException/objc_wrap.h"
    }

    createInterop("foreignExceptionMode_default") {
        it.defFile 'interop/objc/foreignException/objcExceptionMode.def'
        it.headers "$projectDir/interop/objc/foreignException/objc_wrap.h"
    }

    createInterop("foreignExceptionMode_wrap") {
        it.defFile 'interop/objc/foreignException/objcExceptionMode.def'
        it.headers "$projectDir/interop/objc/foreignException/objc_wrap.h"
        it.extraOpts '-Xforeign-exception-mode', "objc-wrap"
    }

    createInterop("objcKt34467") {
        it.defFile 'interop/objc/kt34467/module_library.def'
        def moduleMap = file("interop/objc/kt34467/module_library.modulemap").absolutePath
        def includePath = file("interop/objc/kt34467").absolutePath
        it.compilerOpts "-fmodule-map-file=$moduleMap", "-I$includePath"
    }
    createInterop("objcGh3343") {
        it.defFile 'framework/gh3343/objclib.def'
        it.headers "$projectDir/framework/gh3343/objclib.h"
        it.linkerOpts "-lobjcgh3343"
    }
    createInterop("objc_illegal_sharing_with_weak") {
      it.defFile 'interop/objc/illegal_sharing_with_weak/objclib.def'
      it.headers "$projectDir/interop/objc/illegal_sharing_with_weak/objclib.h"
    }
    createInterop("objcKt43517") {
        it.defFile 'framework/kt43517/kt43517.def'
    }
    createInterop("objc_kt42172") {
        it.defFile 'interop/objc/kt42172/objclib.def'
        it.headers "$projectDir/interop/objc/kt42172/objclib.h"
    }
    createInterop("objc_kt48816") {
        it.defFile 'interop/objc/kt48816/objclib.def'
        it.headers "$projectDir/interop/objc/kt48816/objclib.h"
    }
    createInterop("objc_kt50648") {
        it.defFile 'interop/objc/kt50648/objclib.def'
    }
    createInterop("objc_kt53151") {
        it.defFile 'interop/objc/kt53151/objclib.def'
        it.compilerOpts "-F$projectDir/interop/objc/kt53151/testFramework"
    }
    createInterop("objc_kt55938") {
        it.defFile 'interop/objc/kt55938/objclib.def'
        it.headers "$projectDir/interop/objc/kt55938/objclib.h"
    }

    createInterop("kt49034_struct") {
        it.defFile 'interop/objc/kt49034/struct/kt49034.def'
        it.headers "$projectDir/interop/objc/kt49034/struct/kt49034.h"
        it.extraOpts "-Xcompile-source", "$projectDir/interop/objc/kt49034/struct/impl.c"
    }

    createInterop("kt49034_objcclass") {
        it.defFile 'interop/objc/kt49034/objcclass/kt49034.def'
        it.headers "$projectDir/interop/objc/kt49034/objcclass/kt49034.h"
    }
    createInterop("kt49034_objcprotocol") {
        it.defFile 'interop/objc/kt49034/objcprotocol/kt49034.def'
        it.headers "$projectDir/interop/objc/kt49034/objcprotocol/kt49034.h"
    }
    createInterop("objc_include_categories") {
        it.defFile 'interop/objc/include_categories/objc_include_categories.def'
        it.headers "$projectDir/interop/objc/include_categories/objc_include_categories.h"
    }
    createInterop("frameworkForwardDeclarations") {
        it.defFile 'framework/forwardDeclarations/clib.def'
    }
    createInterop("objc_kt56402") {
        it.defFile 'interop/objc/kt56402/objclib.def'
        it.headers "$projectDir/interop/objc/kt56402/objclib.h"
    }
    createInterop("objCAction") {
        it.defFile 'interop/objc/objCAction/objclib.def'
        it.headers "$projectDir/interop/objc/objCAction/objclib.h"
    }
    createInterop("kt59167") {
        it.defFile 'interop/kt59167/kt59167.def'
    }
}

createInterop("withSpaces") {
    it.defFile generateWithSpaceDefFile()
}

createInterop("exceptions_throwThroughBridge") {
    it.defFile "interop/exceptions/throwThroughBridge.def"
    it.extraOpts "-Xcompile-source", "$projectDir/interop/exceptions/throwThroughBridgeInterop.cpp"
}

createInterop("exceptions_cCallback") {
    it.defFile "interop/exceptions/cCallback.def"
    it.extraOpts "-Xcompile-source", "$projectDir/interop/exceptions/cCallback.cpp"
}

/**
 * Creates a task for the interop test. Configures runner and adds library and test build tasks.
 */
Task interopTestBase(String name, boolean multiFile, boolean interop2ForMainOnly, Closure<KonanInteropTest> configureClosure) {
    return KotlinNativeTestKt.createTest(project, name, KonanInteropTest) { task ->
        task.configure(configureClosure)
        if (task.enabled) {
            konanArtifacts {
                def targetName = target.name
                def interopLib = task.interop
                def interopLib2 = task.interop2
                UtilsKt.dependsOnKonanBuildingTask(task, interopLib, target)
                if (interopLib2 != null) UtilsKt.dependsOnKonanBuildingTask(task, interopLib2, target)

                def lib = "lib$name"
                def hasIntermediateLib = task.lib != null
                if (hasIntermediateLib) {
                    // build a library from KonanLinkTest::lib property
                    library(lib, targets: [targetName]) {
                        libraries {
                            artifact interopLib
                            if (interopLib2 != null && !interop2ForMainOnly) artifact interopLib2
                        }
                        srcFiles task.lib
                        baseDir  "$testOutputLocal/$name"
                        extraOpts task.flags
                        extraOpts project.globalTestArgs.findAll { !it.contains("-Xpartial-linkage") }
                    }
                    UtilsKt.dependsOnKonanBuildingTask(task, lib, target)
                }

                program(name, targets: [targetName]) {
                    libraries {
                        artifact interopLib
                        if (interopLib2 != null) artifact interopLib2
                        if (hasIntermediateLib)
                            klib lib
                    }
                    srcFiles multiFile ? fileTree(task.source) { include '**/*.kt' } : task.getSources()
                    baseDir "$testOutputLocal/$name"
                    linkerOpts "-L$buildDir"
                    extraOpts task.flags
                    extraOpts project.globalTestArgs
                }
            }
        }
    }
}

Task interopTest(String name, Closure<KonanInteropTest> configureClosure) {
    return interopTestBase(name, false, false, configureClosure)
}

Task interopTestMultifile(String name, Closure<KonanInteropTest> configureClosure) {
    return interopTestBase(name, true, false, configureClosure)
}

standaloneTest("interop_objc_allocException") {
    disabled = !isAppleTarget(project)
    expectedExitStatus = 0
    source = "interop/objc/allocException.kt"
    UtilsKt.dependsOnPlatformLibs(it)
}

interopTest("interop_available_processors") {
    source = 'interop/basics/available_processors.kt'
    arguments = [Runtime.getRuntime().availableProcessors().toString()]
    interop = 'cstdlib'
}

interopTest("interop0") {
    disabled = (project.testTarget == 'linux_arm64')
    useGoldenData = true
    source = "interop/basics/0.kt"
    interop = 'sysstat'
}

interopTest("interop1") {
    useGoldenData = true
    source = "interop/basics/1.kt"
    interop = 'cstdlib'
}

interopTest("interop2") {
    useGoldenData = true
    source = "interop/basics/2.kt"
    interop = 'cstdio'
}

interopTest("interop3") {
    useGoldenData = true
    source = "interop/basics/3.kt"
    interop = 'cstdlib'
}

interopTest("interop4") {
    useGoldenData = true
    source = "interop/basics/4.kt"
    interop = 'cstdio'
}

standaloneTest("interop5") {
    useGoldenData = true
    source = "interop/basics/5.kt"
    UtilsKt.dependsOnPlatformLibs(it)
}

interopTest("interop_bitfields") {
    disabled = isAggressiveGC // TODO: Investigate why too slow
    source = "interop/basics/bf.kt"
    interop = 'bitfields'
}

interopTest("interop_funptr") {
    useGoldenData = true
    source = "interop/basics/funptr.kt"
    interop = 'cfunptr'
}

interopTest("interop_globals") {
    source = "interop/basics/globals.kt"
    interop = 'cglobals'
}

interopTest("interop_macros") {
    disabled = isK2(project) // KT-56041
    source = "interop/basics/macros.kt"
    interop = 'cmacros'
}

interopTest("interop_unsupported") {
    source = "interop/basics/unsupported.kt"
    interop = 'cunsupported'
}

interopTest("interop_toKString") {
    source = "interop/basics/toKString.kt"
    interop = 'ctoKString'
}

interopTest("interop_types") {
    source = "interop/basics/types.kt"
    interop = 'ctypes'
}

interopTest("interop_structAnonym") {
    source = "interop/basics/structAnonym.kt"
    interop = 'structAnonym'
}

interopTest("interop_vectors") {
    source = "interop/basics/vectors.kt"
    interop = 'cvectors'
}

interopTest("interop_mangling") {
    source = "interop/basics/mangling.kt"
    interop = 'cmangling'
}

interopTest("interop_mangling2") {
    source = "interop/basics/mangling2.kt"
    interop = 'cmangling2'
}

interopTest("interop_mangling_keywords") {
    source = "interop/basics/mangling_keywords.kt"
    interop = 'cmangling_keywords'
}

interopTest("interop_mangling_keywords2") {
    source = "interop/basics/mangling_keywords2.kt"
    interop = 'cmangling_keywords2'
}

interopTest("interop_auxiliarySources") {
    source = "interop/auxiliary_sources/main.kt"
    interop = 'auxiliaryCppSources'
}

interopTest("interop_concurrentTerminate") {
    source = "interop/concurrentTerminate/main.kt"
    interop = 'concurrentTerminate'
    outputChecker = { str -> str.endsWith("Reporting error!\n") }
    expectedExitStatus = 99
}

interopTest("interop_incompleteTypes") {
    source = "interop/incomplete_types/main.kt"
    interop = 'incomplete_types'
}

interopTest("interop_embedStaticLibraries") {
    source = "interop/embedStaticLibraries/main.kt"
    interop = 'embedStaticLibraries'
}

interopTest("interop_values") {
    source = "interop/basics/values.kt"
    interop = 'cvalues'
}

interopTest("interop_structs") {
    source = "interop/basics/structs.kt"
    interop = 'cstructs'
}

interopTest("interop_callbacksAndVarargs") {
    source = "interop/basics/callbacksAndVarargs.kt"
    interop = 'ccallbacksAndVarargs'
}

interopTest("interop_threadStates") {
    source = "interop/threadStates/threadStates.kt"
    flags = ['-opt-in=kotlin.native.internal.InternalForKotlinNative']
    interop = "threadStates"
}

interopTest("interop_threadStates_callbacksWithExceptions") {
    source = "interop/threadStates/callbacksWithExceptions.kt"
    interop = "threadStates"
    flags = ['-opt-in=kotlin.native.internal.InternalForKotlinNative']
}

interopTest("interop_threadStates_unhandledException") {
    source = "interop/threadStates/unhandledException.kt"
    interop = "threadStates"
    outputChecker = { it.contains("Error. Runnable state: true") }
    expectedExitStatusChecker = { it != 0 }
    flags = ['-opt-in=kotlin.native.internal.InternalForKotlinNative']
}

interopTest("interop_threadStates_unhandledExceptionInForeignThread") {
    source = "interop/threadStates/unhandledExceptionInForeignThread.kt"
    interop = "threadStates"
    outputChecker = { it.contains("Error. Runnable state: true") }
    expectedExitStatusChecker = { it != 0 }
    flags = ['-opt-in=kotlin.native.internal.InternalForKotlinNative']
}

interopTest("interop_withSpaces") {
    interop ='withSpaces'
    source = "interop/basics/withSpaces.kt"

    doLast {
        assert file("${buildDir}/cutom map.map").exists()
    }
}

interopTest("interop_union") {
    interop = 'cunion'
    source = "interop/basics/union.kt"
}

interopTest("interop_enums") {
    interop = 'cenums'
    flags = ['-XXLanguage:+EnumEntries']
    source = "interop/basics/enums.kt"
}

interopTest("interop_array_pointers") {
    interop = 'carrayPointers'
    source = "interop/basics/arrayPointers.kt"
}

interopTest("interop_kt43265") {
    interop = 'kt43265'
    source = "interop/kt43265/usage.kt"
}

interopTest("interop_kt44283") {
    disabled = project.globalTestArgs.contains('-opt') // Incompatible with -g.
    flags = ['-g']
    interop = 'kt44283'
    source = "interop/kt44283/main.kt"
}

interopTest("interop_kt54284") {
    interop = 'kt54284'
    source = "interop/kt54284/main.kt"
}

interopTest("interop_kt54284_fmodules") {
    interop = 'kt54284_fmodules'
    source = "interop/kt54284/main.kt"
}

// TODO: This test should be run with caches on.
interopTest("interop_kt51925") {
    interop = 'kt51925'
    lib = 'interop/kt51925/kt51925_lib.kt'
    source = 'interop/kt51925/kt51925_main.kt'
    useGoldenData = true
}

interopTestBase("interop_forwardDeclarationsCast", false, true) {
    enabled = isAppleTarget(project)
    interop = 'forwardDeclarationsCastA'
    interop2 = 'forwardDeclarationsCastB'
    lib = 'interop/forwardDeclarationsCast/lib.kt'
    source = 'interop/forwardDeclarationsCast/main.kt'
}

dynamicTest("interop_kt43502") {
    interop = "kt43502"
    source = "interop/kt43502/main.kt"
    cSource = "$projectDir/interop/kt43502/main.c"
    useGoldenData = true
}

interopTest("interop_leakMemoryWithRunningThreadUnchecked") {
    interop = 'leakMemoryWithRunningThread'
    source = "interop/leakMemoryWithRunningThread/unchecked.kt"
}

interopTest("interop_leakMemoryWithRunningThreadChecked") {
    interop = 'leakMemoryWithRunningThread'
    source = "interop/leakMemoryWithRunningThread/checked.kt"
    expectedExitStatusChecker = { it != 0 }
    outputChecker = { s -> s.contains("Cannot run checkers when there are 1 alive runtimes at the shutdown") }
}

standaloneTest("interop_pinning") {
    source = "interop/basics/pinning.kt"
    flags = [ "-tr" ]
}

tasks.register("interop_convert", KonanLocalTest) {
    source = "codegen/intrinsics/interop_convert.kt"
}

tasks.register("interop_sourceCodeStruct", KonanLocalTest) {
    source = "codegen/intrinsics/interop_sourceCodeStruct.kt"
}

tasks.register("interop_alloc_value", KonanLocalTest) {
    source = "runtime/interop/interop_alloc_value.kt"
}

standaloneTest("isExperimentalMM") {
    source = "codegen/intrinsics/isExperimentalMM.kt"
    flags = [ "-tr" ]
}

interopTest("interop_cppClass") {
    disabled = isAppleTarget(project) // KT-58422
    source = "interop/cpp/cppClass.kt"
    interop = 'cppClass'
}

interopTest("interop_cppTypes") {
    disabled = isAppleTarget(project) // KT-58422
    source = "interop/cpp/types.kt"
    interop = 'cppTypes'
}

interopTest("interop_cppSkia") {
    disabled = true // KT-58422
    source = "interop/cpp/skia.kt"
    interop = 'cppSkia'
    useGoldenData = true
    UtilsKt.dependsOnPlatformLibs(it)
}

interopTest("interop_cppSkiaSignature") {
    disabled = isAppleTarget(project) // KT-58422
    source = "interop/cpp/skiaSignature.kt"
    interop = "cppSkiaSignature"
    useGoldenData = true
    UtilsKt.dependsOnPlatformLibs(it)
}

interopTest("interop_workerSignals") {
    disabled = project.testTarget == 'mingw_x64' // cross-thread signalling does not work on Windows
    source = "interop/workerSignals/workerSignals.kt"
    interop = "workerSignals"
}

interopTest("interop_forwardDeclarations") {
    source = "interop/forwardDeclarations/forwardDeclarations.kt"
    interop = "cForwardDeclarations"
}

interopTest("interop_forwardDeclarationsTwoLibs") {
    source = "interop/forwardDeclarationsTwoLibs/forwardDeclarationsTwoLibs.kt"
    interop = "cForwardDeclarationsTwoLibs1"
    interop2 = "cForwardDeclarationsTwoLibs2"
}

/*
TODO: This test isn't run automatically
tasks.register("interop_echo_server", RunInteropKonanTest) {
    disabled = isWasmTarget(project) || isWindowsTarget(project)
    run = false
    source = "interop/basics/echo_server.kt"
    interop = 'sockets'
}
*/

/*
TODO: This test isn't run automatically
standaloneTest("interop_opengl_teapot") {
    enabled = isAppleTarget(project) && project.testTarget != 'ios_x64'  // No GLUT in iOS
    dependsOnPlatformLibs(it as Task)
    run = false
    source = "interop/basics/opengl_teapot.kt"
}
*/

if (PlatformInfo.isAppleTarget(project)) {
    interopTest("interop_objc_smoke") {
        enabled = !isNoopGC
        source = "interop/objc/smoke.kt"
        interop = 'objcSmoke'
        doBeforeBuild {
            mkdir(buildDir)
            project.extensions.execClang.execClangForCompilerTests(project.target) {
                args "$projectDir/interop/objc/smoke.m"
                args "-lobjc", '-fobjc-arc'
                args '-fPIC', '-shared', '-o', "$buildDir/libobjcsmoke.dylib"
                // Enable ARC optimizations to prevent some objects from leaking in Obj-C code due to exceptions:
                args '-O2'
            }
            if (UtilsKt.isSimulatorTarget(project, project.target)) {
                UtilsKt.codesign(project, "$buildDir/libobjcsmoke.dylib")
            }

            copy {
                from("interop/objc/Localizable.stringsdict")
                into("$testOutputLocal/$name/$target/en.lproj/")
            }
        }
        useGoldenData = true
    }

    interopTest("interop_objc_smoke_noopgc") {
        enabled = isNoopGC
        source = "interop/objc/smoke_noopgc.kt"
        interop = 'objcSmoke'
        verifyIr = false  // KT-57716
        doBeforeBuild {
            mkdir(buildDir)
            project.extensions.execClang.execClangForCompilerTests(project.target) {
                args "$projectDir/interop/objc/smoke.m"
                args "-lobjc", '-fobjc-arc'
                args '-fPIC', '-shared', '-o', "$buildDir/libobjcsmoke.dylib"
                // Enable ARC optimizations to prevent some objects from leaking in Obj-C code due to exceptions:
                args '-O2'
            }
            if (UtilsKt.isSimulatorTarget(project, project.target)) {
                UtilsKt.codesign(project, "$buildDir/libobjcsmoke.dylib")
            }

            copy {
                from("interop/objc/Localizable.stringsdict")
                into("$testOutputLocal/$name/$target/en.lproj/")
            }
        }
        // No deallocations for the no-op GC.
        useGoldenData = true
    }

    interopTestMultifile("interop_objc_tests") {
        source = "interop/objc/tests/"
        interop = 'objcTests'
        flags = ['-tr', '-e', 'main', '-opt-in=kotlin.native.internal.InternalForKotlinNative']

        if (isNoopGC) {
            def exclude = [
                    "Kt41811Kt.*",
                    "CustomStringKt.testCustomString",
                    "Kt42482Kt.testKT42482",
                    "ObjcWeakRefsKt.testObjCWeakRef",
                    "WeakRefsKt.testWeakRefs"
            ]
            arguments += ["--ktest_filter=*-${exclude.join(":")}"]
        }

        doBeforeBuild {
            mkdir(buildDir)
            project.extensions.execClang.execClangForCompilerTests(project.target) {
                args fileTree("$projectDir/interop/objc/tests/") { include '**/*.m' }
                args "-lobjc", '-fobjc-arc'
                args '-fPIC', '-shared', '-o', "$buildDir/libobjctests.dylib"
                // Enable ARC optimizations to prevent some objects from leaking in Obj-C code due to exceptions:
                args '-O2'
            }
            if (UtilsKt.isSimulatorTarget(project, project.target)) {
                UtilsKt.codesign(project, "$buildDir/libobjctests.dylib")
            }
        }
    }

    // KT-49034 tests don't need whole compilation pipeline (only frontend) or platform libraries. Consider simplifying them when porting
    // to the new test infra.
    interopTest("interop_kt49034_struct") {
        interop = 'kt49034_struct'
        source = 'interop/objc/kt49034/struct/main.kt'

        // The test depends on collision between kt49034.JSContext and platform.JavaScriptCore.JSContext
        UtilsKt.dependsOnPlatformLibs(it)
    }

    interopTest("interop_kt49034_objcclass") {
        interop = 'kt49034_objcclass'
        source = 'interop/objc/kt49034/objcclass/main.kt'

        // The test depends on collision between kt49034.__darwin_fp_control and platform.darwin.__darwin_fp_control
        UtilsKt.dependsOnPlatformLibs(it)
    }


    interopTest("interop_objc_global_initializer") {
        useGoldenData = true
        source = "interop/objc_with_initializer/objc_test.kt"
        interop = 'objcMisc'

        doBeforeBuild {
            mkdir(buildDir)
            project.extensions.execClang.execClangForCompilerTests(project.target) {
                args "$projectDir/interop/objc_with_initializer/objc_misc.m"
                args "-lobjc", '-fobjc-arc'
                args '-fPIC', '-shared', '-o', "$buildDir/libobjcmisc.dylib"
            }
            if (UtilsKt.isSimulatorTarget(project, project.target)) {
                UtilsKt.codesign(project, "$buildDir/libobjcmisc.dylib")
            }
        }
    }

    interopTest("interop_objc_msg_send") {
        source = "interop/objc/msg_send/main.kt"
        interop = 'objcMessaging'

        doBeforeBuild {
            mkdir(buildDir)
            project.extensions.execClang.execClangForCompilerTests(project.target) {
                args "$projectDir/interop/objc/msg_send/messaging.m"
                args "-lobjc", '-fobjc-arc'
                args '-fPIC', '-shared', '-o', "$buildDir/libobjcmessaging.dylib"
            }
            if (UtilsKt.isSimulatorTarget(project, project.target)) {
                UtilsKt.codesign(project, "$buildDir/libobjcmessaging.dylib")
            }
        }
    }

    interopTest("interop_objc_direct") {
        source = "interop/objc/direct/main.kt"
        interop = "objcDirect"
    }

    interopTest("interop_objc_foreignException") {
        source = "interop/objc/foreignException/objc_wrap.kt"
        interop = 'foreignException'
        UtilsKt.dependsOnPlatformLibs(it)

        doBeforeBuild {
            mkdir(buildDir)
            project.extensions.execClang.execClangForCompilerTests(project.target) {
                args "$projectDir/interop/objc/foreignException/objc_wrap.m"
                args "-lobjc", '-fobjc-arc'
                args '-fPIC', '-shared', '-o', "$buildDir/libobjcexception.dylib"
            }
            if (UtilsKt.isSimulatorTarget(project, project.target)) {
                UtilsKt.codesign(project, "$buildDir/libobjcexception.dylib")
            }
        }
    }

    interopTest("interop_objc_foreignExceptionMode_wrap") {
        source = "interop/objc/foreignException/objcExceptionMode_wrap.kt"
        interop = 'foreignExceptionMode_wrap'
        useGoldenData = true
        UtilsKt.dependsOnPlatformLibs(it)

        doBeforeBuild {
            mkdir(buildDir)
            project.extensions.execClang.execClangForCompilerTests(project.target) {
                args "$projectDir/interop/objc/foreignException/objc_wrap.m"
                args "-lobjc", '-fobjc-arc'
                args '-fPIC', '-shared', '-o', "$buildDir/libobjcexception.dylib"
            }
            if (UtilsKt.isSimulatorTarget(project, project.target)) {
                UtilsKt.codesign(project, "$buildDir/libobjcexception.dylib")
            }
        }
    }

    interopTest("interop_objc_foreignExceptionMode_default") {
        source = "interop/objc/foreignException/objcExceptionMode_default.kt"
        interop = 'foreignExceptionMode_default'
        useGoldenData = true
        UtilsKt.dependsOnPlatformLibs(it)

        doBeforeBuild {
            mkdir(buildDir)
            project.extensions.execClang.execClangForCompilerTests(project.target) {
                args "$projectDir/interop/objc/foreignException/objc_wrap.m"
                args "-lobjc", '-fobjc-arc'
                args '-fPIC', '-shared', '-o', "$buildDir/libobjcexception.dylib"
            }
            if (UtilsKt.isSimulatorTarget(project, project.target)) {
                UtilsKt.codesign(project, "$buildDir/libobjcexception.dylib")
            }
        }
    }

    interopTest("interop_objc_kt34467") {
        source = "interop/objc/kt34467/foo.kt"
        interop = 'objcKt34467'
        useGoldenData = true
    }

    interopTest("interop_objc_illegal_sharing_with_weak") {
        source = "interop/objc/illegal_sharing_with_weak/main.kt"
        interop = 'objc_illegal_sharing_with_weak'
        // Experimental MM supports arbitrary object sharing.
        outputChecker = { it == "Before\nAfter true\n" }
    }

    interopTest("interop_objc_kt42172") {
        enabled = !isNoopGC
        source = "interop/objc/kt42172/main.kt"
        interop = "objc_kt42172"
        flags = ['-opt-in=kotlin.native.internal.InternalForKotlinNative']
        useGoldenData = true

        doBeforeBuild {
            mkdir(buildDir)
            project.extensions.execClang.execClangForCompilerTests(project.target) {
                args "$projectDir/interop/objc/kt42172/objclib.m"
                args "-lobjc", '-fobjc-arc'
                args '-fPIC', '-shared', '-o', "$buildDir/libobjc_kt42172.dylib"
            }
            if (UtilsKt.isSimulatorTarget(project, project.target)) {
                UtilsKt.codesign(project, "$buildDir/libobjc_kt42172.dylib")
            }
        }

    }

    interopTest("interop_objc_kt48816_without_lazy_ir_for_caches") {
        // Without a fix, fails in two-stage mode.
        source = "interop/objc/kt48816/main.kt"
        interop = "objc_kt48816"
        // The bug was accidentally fixed with lazy IR for caches, so testing it with this feature disabled:
        flags = ["-Xlazy-ir-for-caches=disable"]
    }

    interopTest("interop_objc_kt48816_with_lazy_ir_for_caches") {
        source = "interop/objc/kt48816/main.kt"
        interop = "objc_kt48816"
        flags = ["-Xlazy-ir-for-caches=enable"]
    }

    interopTest("interop_objc_kt50648") {
        source = 'interop/objc/kt50648/main.kt'
        interop = "objc_kt50648"
        expectedExitStatusChecker = { it != 0 }
        outputChecker = {
            it.contains("Converting Obj-C blocks with non-reference-typed return value to kotlin.Any is not supported (v)") &&
                    (it.contains("kfun:#main(){}") || project.globalTestArgs.contains('-opt')) // Stacktrace.
        }
    }

    interopTest("interop_objc_kt53151") {
        source = "interop/objc/kt53151/main.kt"
        interop = "objc_kt53151"
    }

    interopTest("interop_objc_kt55938") {
        source = "interop/objc/kt55938/main.kt"
        lib = "interop/objc/kt55938/lib.kt"
        interop = "objc_kt55938"
        useGoldenData = true
        enabled = cacheTesting != null
        flags = [
                "-Xauto-cache-from=$testOutputRoot/local/objc_kt55938",
                "-Xauto-cache-from=$testOutputRoot/local/interop_objc_kt55938",
                "-Xauto-cache-dir=$testOutputRoot/local/interop_objc_kt55938/cache",
                "-Xsuppress-version-warnings",  // suppresses warning about experimental language version, otherwise test fails with K2 due to -Werror
                "-Werror" // to forbid retry with auto-cache disabled
        ]

        UtilsKt.findKonanBuildTask(project, "objc_kt55938", target).configure {
            it.doFirst {
                def cacheDir = new File("$testOutputRoot/local/interop_objc_kt55938/cache")
                cacheDir.deleteDir()
                mkdir(cacheDir)
            }
        }

        doBeforeBuild {
            mkdir(buildDir)
            project.extensions.execClang.execClangForCompilerTests(project.target) {
                args "$projectDir/interop/objc/kt55938/objclib.m"
                args "-lobjc", '-fobjc-arc'
                args '-fPIC', '-shared', '-o', "$buildDir/libobjc_kt55938.dylib"
            }
            if (UtilsKt.isSimulatorTarget(project, project.target)) {
                UtilsKt.codesign(project, "$buildDir/libobjc_kt55938.dylib")
            }
        }
    }

    standaloneTest("objc_arc_contract") {
        doBeforeBuild {
            mkdir(buildDir)
            ExecLlvmKt.execLlvmUtility(project, "llvm-as") {
                args "$projectDir/interop/objc_arc_contract/main.ll"
                args "-o", "$buildDir/objc_arc_contract.bc"
            }
        }
        source = "interop/objc_arc_contract/main.kt"
        useGoldenData = true
        flags = ["-native-library", "$buildDir/objc_arc_contract.bc"]
    }

    interopTest("interop_objc_include_categories") {
        useGoldenData = true
        source = "interop/objc/include_categories/main.kt"
        interop = "objc_include_categories"
        doBeforeBuild {
            mkdir(buildDir)
            project.extensions.execClang.execClangForCompilerTests(project.target) {
                args "$projectDir/interop/objc/include_categories/objc_include_categories.m"
                args "-lobjc", '-fobjc-arc'
                args '-fPIC', '-shared', '-o', "$buildDir/libobjcincludecategories.dylib"
            }
            if (UtilsKt.isSimulatorTarget(project, project.target)) {
                UtilsKt.codesign(project, "$buildDir/libobjcincludecategories.dylib")
            }
        }
    }

    standaloneTest("interop_kt55653") {
        // Test depends on macOS-specific AppKit
        enabled = (project.testTarget == 'macos_x64' || project.testTarget == 'macos_arm64' || project.testTarget == null)
        source = "interop/objc/kt55653/main.kt"
        useGoldenData = true
        UtilsKt.dependsOnPlatformLibs(it)
    }

    standaloneTest("interop_kt40426") {
        // Test depends on iOS-specific UIKit
        enabled = (project.testTarget == 'ios_x64' || project.testTarget == 'ios_simulator_arm64' || project.testTarget == 'ios_arm64')
        source = "interop/objc/kt40426/main.kt"
        useGoldenData = true
        UtilsKt.dependsOnPlatformLibs(it)
    }

    interopTest("interop_objc_kt56402") {
        // Test depends on macOS-specific AppKit
        enabled = (project.testTarget == 'macos_x64' || project.testTarget == 'macos_arm64' || project.testTarget == null)
            && !isNoopGC // requires some GC
        source = 'interop/objc/kt56402/main.kt'
        interop = "objc_kt56402"
        flags = ["-tr", "-e", "runAllTests"] // Generate test suites, but use custom entrypoint.

        doBeforeBuild {
            mkdir(buildDir)
            project.extensions.execClang.execClangForCompilerTests(project.target) {
                args "$projectDir/interop/objc/kt56402/objclib.m"
                args "-lobjc", '-fobjc-arc'
                args '-fPIC', '-shared', '-o', "$buildDir/libobjc_kt56402.dylib"
                args '-framework', 'AppKit'
            }
            if (UtilsKt.isSimulatorTarget(project, project.target)) {
                UtilsKt.codesign(project, "$buildDir/libobjc_kt56402.dylib")
            }
        }
    }

    interopTest("interop_objCAction") {
        source = 'interop/objc/objCAction/main.kt'
        interop = "objCAction"
        flags = ["-tr"]
        doBeforeBuild {
            mkdir(buildDir)
            project.extensions.execClang.execClangForCompilerTests(project.target) {
                args "$projectDir/interop/objc/objCAction/objclib.m"
                args "-lobjc", '-fobjc-arc'
                args '-fPIC', '-shared', '-o', "$buildDir/libobjCAction.dylib"
            }
            if (UtilsKt.isSimulatorTarget(project, project.target)) {
                UtilsKt.codesign(project, "$buildDir/libobjCAction.dylib")
            }
        }
        UtilsKt.dependsOnPlatformLibs(it)
    }

    interopTest("interop_kt59167") {
        // There is no GameController on watchOS.
        enabled = target.family != Family.WATCHOS
        source = 'interop/kt59167/main.kt'
        interop = 'kt59167'
    }
}

tasks.register("KT-50983", KonanDriverTest) {
    // The test is not working on Windows Server 2019-based TeamCity agents for the unknown reason.
    // TODO: Re-enable it after LLVM update where llvm-windres will be added.
    enabled = false
    doBeforeBuild {
        mkdir(buildDir)
        exec {
            commandLine UtilsKt.binaryFromToolchain(project, "windres")
            args "$projectDir/windows/KT-50983/File.rc", "-O", "coff", "-o", "$buildDir/File.res"
        }
    }
    source = "windows/KT-50983/main.kt"
    flags = ['-linker-option', "$buildDir/File.res"]
}

standaloneTest("interop_libiconv") {
    enabled = (project.testTarget == null)
    source = "interop/libiconv.kt"
    useGoldenData = true
    UtilsKt.dependsOnPlatformLibs(it)
}

standaloneTest("interop_zlib") {
    enabled = (project.testTarget == null)
    source = "interop/platform_zlib.kt"
    useGoldenData = true
    UtilsKt.dependsOnPlatformLibs(it)
}

standaloneTest("interop_objc_illegal_sharing") {
    disabled = !isAppleTarget(project)
    source = "interop/objc/illegal_sharing.kt"
    UtilsKt.dependsOnPlatformLibs(it)
    outputChecker = {
        it.startsWith("Before") && it.contains("After")
    }
}

dynamicTest("produce_dynamic") {
    source = "produce_dynamic/simple/hello.kt"
    cSource = "$projectDir/produce_dynamic/simple/main.c"
    useGoldenData = true
}

dynamicTest("kt36639") {
    source = "produce_dynamic/kt-36639/main.kt"
    cSource = "$projectDir/produce_dynamic/kt-36639/main.c"
    useGoldenData = true
}

dynamicTest("kt36878") {
    source = "produce_dynamic/kt-36878/hello.kt"
    cSource = "$projectDir/produce_dynamic/kt-36878/main.c"
    useGoldenData = true
}

dynamicTest("kt39015") {
    source = "produce_dynamic/kt-39015/hello.kt"
    cSource = "$projectDir/produce_dynamic/kt-39015/main.c"
    useGoldenData = true
}

dynamicTest("kt39496") {
    source = "produce_dynamic/kt-39496/hello.kt"
    cSource = "$projectDir/produce_dynamic/kt-39496/main.c"
    useGoldenData = true
}

dynamicTest("kt41904") {
    source = "produce_dynamic/kt-41904/hello.kt"
    cSource = "$projectDir/produce_dynamic/kt-41904/main.c"
    useGoldenData = true
}

for (i in 0..2) {
    dynamicTest("kt42796_$i") {
        clangTool = "clang++"
        source = "produce_dynamic/kt-42796/main-${i}.kt"
        cSource = "$projectDir/produce_dynamic/kt-42796/main.cpp"
        useGoldenData = true
        clangFlags = ["-DTEST=$i", "-Werror"]
    }
}

dynamicTest("kt42830") {
    source = "produce_dynamic/kt-42830/box_unbox.kt"
    cSource = "$projectDir/produce_dynamic/kt-42830/main.c"
    useGoldenData = true
}

dynamicTest("produce_dynamic_unhandledException") {
    disabled = (cacheTesting != null) // Disabled due to KT-47828.
    source = "produce_dynamic/unhandledException/unhandled.kt"
    cSource = "$projectDir/produce_dynamic/unhandledException/main.cpp"
    clangTool = "clang++"
    expectedExitStatusChecker = { it != 0 }
    outputChecker = { str -> str.startsWith("Kotlin hook: Exception. Runnable state: true") }
    flags = ['-opt-in=kotlin.native.internal.InternalForKotlinNative']
}

dynamicTest("interop_concurrentRuntime") {
    disabled = true  // KT-43180
    source = "interop/concurrentTerminate/reverseInterop.kt"
    cSource = "$projectDir/interop/concurrentTerminate/main.cpp"
    clangTool = "clang++"
    outputChecker = { str -> str.startsWith("Uncaught Kotlin exception: kotlin.RuntimeException: Example") }
    expectedExitStatus = 99
}

for (i in ["kt42397", "kt56182_root", "kt56182_package1lvl", "kt56182_subpackage2lvl", "kt56182_root_package1lvl", "kt56182_root_subpackage2lvl"]) {
    // note: kt56182_package1lvl is same as kt42397
    // note: kt56182_root_package1lvl is similar as kt41904
    // note: kt56182_subpackage2lvl is similar as kt42796_1
    dynamicTest("interop_$i") {
        source = "interop/$i/knlibrary.kt"
        cSource = "$projectDir/interop/$i/test.cpp"
        clangTool = "clang++"
    }
}

dynamicTest("interop_cleaners_main_thread") {
    disabled = isNoopGC
    source = "interop/cleaners/cleaners.kt"
    cSource = "$projectDir/interop/cleaners/main_thread.cpp"
    clangTool = "clang++"
    useGoldenData = true
    flags = ['-opt-in=kotlin.native.internal.InternalForKotlinNative']
}

dynamicTest("interop_cleaners_second_thread") {
    disabled = isNoopGC
    source = "interop/cleaners/cleaners.kt"
    cSource = "$projectDir/interop/cleaners/second_thread.cpp"
    clangTool = "clang++"
    useGoldenData = true
    flags = ['-opt-in=kotlin.native.internal.InternalForKotlinNative']
}

dynamicTest("interop_cleaners_leak") {
    source = "interop/cleaners/cleaners.kt"
    cSource = "$projectDir/interop/cleaners/leak.cpp"
    clangTool = "clang++"
    useGoldenData = true
    flags = ['-opt-in=kotlin.native.internal.InternalForKotlinNative']
}

dynamicTest("interop_migrating_main_thread") {
    source = "interop/migrating_main_thread/lib.kt"
    clangFlags = ['-DEXPERIMENTAL_MM']
    cSource = "$projectDir/interop/migrating_main_thread/main.cpp"
    clangTool = "clang++"
}

dynamicTest("interop_exceptions_throwThroughBridge") {
    source = "interop/exceptions/throwThroughBridge.kt"
    cSource = "$projectDir/interop/exceptions/throwThroughBridge.cpp"
    clangTool = "clang++"
    expectedExitStatusChecker = { it != 0 }
    outputChecker = { s -> !s.contains("Should not happen") }
    interop = "exceptions_throwThroughBridge"
}

dynamicTest("interop_kotlin_exception_hook") {
    source = "interop/exceptions/exceptionHook.kt"
    cSource = "$projectDir/interop/exceptions/exceptionHook.cpp"
    clangTool = "clang++"
    expectedExitStatusChecker = { it != 0 }
    outputChecker = { s -> s.contains("OK. Kotlin unhandled exception hook") }
}

interopTest("interop_exceptions_cCallback") {
    source = "interop/exceptions/cCallback.kt"
    outputChecker = { s -> s.contains("CATCH IN C++") }
    interop = "exceptions_cCallback"
}

tasks.register("library_ir_provider_mismatch", KonanDriverTest) {
    disabled = isAggressiveGC // No need to test with different GC schedulers

    def dir = buildDir.absolutePath
    def lib = "$projectDir/link/ir_providers/library/empty.kt"
    def invalidManifest = "$projectDir/link/ir_providers/library/manifest.properties"

    def currentTarget = project.target.name

    doBeforeBuild {
        konanc("$lib -p library -o $dir/supported_ir_provider/empty -target $currentTarget")
        konanc("$lib -p library -o $dir/unsupported_ir_provider/empty -manifest $invalidManifest -target $currentTarget")

    }
    source = "link/ir_providers/hello.kt"
    flags = ['-target', currentTarget, '-l', 'empty', '-r', "$dir/unsupported_ir_provider", '-r', "$dir/supported_ir_provider"]
    compilerMessages = true
    def messages = "warning: skipping $dir/unsupported_ir_provider/empty.klib. The library requires unknown IR provider UNSUPPORTED.\nhello\n"
    messages = PlatformInfo.isWindows() ? messages.replaceAll('\\/', '\\\\') : messages
    outputChecker = { out ->
        messages.split("\n")
                .collect { line -> out.contains(line) }
                .every { it == true }
    }
}

standaloneTest("kt51302") {
    enabled = project.target.name == project.hostName
    source = "serialization/KT-51302/main.kt"
    flags = ["-l", "$projectDir/serialization/KT-51302/kt51302_dependency"]
}

standaloneTest("fake_override_0") {
    def sources = "$projectDir/link/fake_overrides"
    def dir = buildDir.absolutePath
    doBeforeBuild {
        konanc("$sources/base.kt -p library -target ${target.name} -o $dir/base")
        konanc("$sources/move.kt -p library -target ${target.name} -o $dir/move -r $dir -l base")
        konanc("$sources/use.kt -p library -target ${target.name} -o $dir/use -r $dir -l move")
        konanc("$sources/move2.kt -p library -target ${target.name} -o $dir/move -r $dir -l base")
    }
    source = "$sources/main.kt"
    flags = ["-l", "use", "-r", "$dir"]
    useGoldenData = true
}

standaloneTest("split_compilation_pipeline") {
    // Test infrastructure does not support passing flags only to the second stage,
    // and we can't pass -Xcompile-from-bitcode when producing library. Thus, this test
    // does not support 2-stage compilation for now.
    // Also, it is failing for some reason on Windows CI, but since MinGW targets are not inteneded
    // to use this mode, we can disable it for these targets.
    enabled = !twoStageEnabled && project.target.name != "mingw_x64" && project.target.name != "mingw_x86"
    def dir = buildDir.absolutePath
    source = "link/private_fake_overrides/override_main.kt"
    doBeforeBuild {
        konanc("$projectDir/link/private_fake_overrides/override_lib.kt -p library -target ${target.name} -o $dir/lib")
        konanc("$projectDir/$source -target ${target.name} -o $dir/out -r $dir -l lib " +
                "-Xtemporary-files-dir=$dir/tmp/split " +
                "-Xwrite-dependencies-to=${dir}/split_compilation_pipeline.deps")
    }
    flags = ["-Xread-dependencies-from=${dir}/split_compilation_pipeline.deps", "-Xcompile-from-bitcode=${dir}/tmp/split/out.bc"]
    useGoldenData = true
}

linkTest("private_fake_overrides_0") {
    source = "link/private_fake_overrides/inherit_main.kt"
    lib = "link/private_fake_overrides/inherit_lib.kt"
    useGoldenData = true
}

linkTest("private_fake_overrides_1") {
    source = "link/private_fake_overrides/override_main.kt"
    lib = "link/private_fake_overrides/override_lib.kt"
    useGoldenData = true
}

Task frameworkTest(String name, Closure<FrameworkTest> configurator) {
    return KotlinNativeTestKt.createTest(project, name, FrameworkTest) { task ->
        configurator.delegate = task
        UtilsKt.dependsOnDist(task)
        configurator()
        if (task.enabled) {
            konanArtifacts {
                task.frameworks.forEach { fr ->
                    framework(fr.name, targets: [target.name]) {
                        fr.sources.forEach { src ->
                            srcFiles src
                        }
                        baseDir "$testOutputFramework/${task.name}"

                        fr.libraries.forEach { library ->
                            dependsOn konanArtifacts[library].getByTarget(target.name)
                            libraries {
                                file konanArtifacts[library].getArtifactByTarget(target.name)
                            }
                            linkerOpts "-L$buildDir"
                            UtilsKt.dependsOnKonanBuildingTask(task, library, target)
                        }

                        extraOpts fr.bitcode ? "-Xembed-bitcode" : "-Xembed-bitcode-marker"
                        if (fr.isStatic) extraOpts "-Xstatic-framework"
                        extraOpts fr.opts
                        extraOpts project.globalTestArgs

                        artifactName fr.artifact
                    }
                    UtilsKt.dependsOnDist(project.tasks.findByName("compileKonan${fr.name.capitalize()}${UtilsKt.getTestTargetSuffix(project)}"))
                }
            }
        }
    }
}

Task objcExportTest(
        Task allTask,
        String suffix,
        List<String> frameworkOpts,
        List<String> swiftOpts,
        Boolean isStaticFramework,
        Boolean needLazyHeaderCheck
) {
    needLazyHeaderCheck = needLazyHeaderCheck && !isK2(project)  // generating lazy headers is NYI in K2
    final String name = "testObjCExport$suffix"
    final String frameworkName = "Kt$suffix"
    final String expectedLazyHeaderName = "expectedLazy${suffix}.h"
    final Task task = frameworkTest(name) {
        final String dir = "$testOutputFramework/$name"
        final File lazyHeader = file("$dir/$target-lazy.h")
        lazyHeader.delete()  // Clean up after previous runs

        doLast {
            // Check lazy header.
            if (needLazyHeaderCheck) {
                final String expectedLazyHeaderDir = file("objcexport/")
                final File expectedLazyHeader = new File(expectedLazyHeaderDir, expectedLazyHeaderName)

                if (!expectedLazyHeader.exists() || expectedLazyHeader.readLines() != lazyHeader.readLines()) {
                    exec {
                        commandLine 'diff', '-u', expectedLazyHeader, lazyHeader
                        ignoreExitValue = true
                    }

                    copy {
                        from(lazyHeader)
                        into(expectedLazyHeaderDir)
                        rename { expectedLazyHeaderName }
                    }

                    throw new Error("$expectedLazyHeader file patched;\nRun gradlew ${allTask.path} --continue and don't forget to commit the patch")
                }
            }

            // Check bundle ID.
            final String frameworkPath = "$dir/$target/Kt.framework"
            final Pattern pattern = ~"<key>CFBundleIdentifier</key>\n\\s*<string>foo.bar</string>"
            final String plistPath = (target.family == Family.OSX) ?
                    "$frameworkPath/Resources/Info.plist" :
                    "$frameworkPath/Info.plist"
            final String plistContent = file(plistPath).text
            if (!pattern.matcher(plistContent).find()) {
                throw new Error("Unexpected Info.plist content:\n$plistContent")
            }
        }

        def libraryName = frameworkName + "Library"
        def noEnumEntriesLibraryName = frameworkName + "NoEnumEntriesLibrary"
        konanArtifacts {
            library(libraryName, targets: [target.name]) {
                srcDir "objcexport/library"
                artifactName "test-$libraryName"
                delegate.getByTarget(target.name).configure{
                    UtilsKt.dependsOnDist(it)
                }

                extraOpts "-Xshort-module-name=MyLibrary"
                extraOpts "-module-name", "org.jetbrains.kotlin.native.test-library"
            }
            library(noEnumEntriesLibraryName, targets: [target.name]) {
                srcDir "objcexport/noEnumEntries"
                artifactName "test-no-enum-entries-$libraryName"
                delegate.getByTarget(target.name).configure{
                    UtilsKt.dependsOnDist(it)
                }

                extraOpts "-Xshort-module-name=NoEnumEntriesLibrary"
                extraOpts "-module-name", "org.jetbrains.kotlin.native.test-no-enum-entries-library"
                extraOpts "-XXLanguage:-EnumEntries"
            }
        }
        codesign = !isStaticFramework
        framework(frameworkName) {
            sources = ['objcexport']
            libraries = [libraryName, noEnumEntriesLibraryName]
            artifact = 'Kt'
            bitcode = !isStaticFramework
            isStatic = isStaticFramework
            if (needLazyHeaderCheck) {
                opts += "-Xemit-lazy-objc-header=$lazyHeader"
            }
            opts += [
                    "-Xexport-kdoc",
                    "-Xbinary=bundleId=foo.bar",
                    "-Xexport-library=test-no-enum-entries-${libraryName}.klib",
                    "-module-name", "Kt"
            ]
            opts += frameworkOpts
        }
        swiftSources = ['objcexport']
        swiftExtraOpts = swiftOpts
        if (isNoopGC) {
            swiftExtraOpts += ["-D", "NOOP_GC"]
        }
        if (isAggressiveGC) {
            swiftExtraOpts += ["-D", "AGGRESSIVE_GC"]
        }
    }
    allTask.dependsOn(task)
    return task
}



if (isAppleTarget(project)) {
    final Task ObjCExportAllTask = tasks.create("testObjCExportAll")
    objcExportTest(
            ObjCExportAllTask,
            '',
            [],
            [],
            false,
            true
    )
    objcExportTest(
            ObjCExportAllTask,
            'NoGenerics',
            ["-Xno-objc-generics"],
            [ '-D', 'NO_GENERICS' ],
            false,
            true
    )
    objcExportTest(
            ObjCExportAllTask,
            'LegacySuspendUnit',
            ["-Xbinary=unitSuspendFunctionObjCExport=legacy"],
            [ '-D', 'LEGACY_SUSPEND_UNIT_FUNCTION_EXPORT' ],
            false,
            true
    )
    objcExportTest(
            ObjCExportAllTask,
            'NoSwiftMemberNameMangling',
            ["-Xbinary=objcExportDisableSwiftMemberNameMangling=true"],
            [ '-D', 'DISABLE_MEMBER_NAME_MANGLING' ],
            false,
            false
    )
    objcExportTest(
            ObjCExportAllTask,
            'NoInterfaceMemberNameMangling',
            ["-Xbinary=objcExportIgnoreInterfaceMethodCollisions=true"],
            [ '-D', 'DISABLE_INTERFACE_METHOD_NAME_MANGLING' ],
            false,
            false
    )

    objcExportTest(
            ObjCExportAllTask,
            'Static',
            ["-Xbinary=objcExportSuspendFunctionLaunchThreadRestriction=none"],
            [ '-D', 'ALLOW_SUSPEND_ANY_THREAD' ],
            true,
            false
    )


    frameworkTest('testValuesGenericsFramework') {
        framework('ValuesGenerics') {
            sources = ['objcexport/values.kt', 'framework/values_generics']
        }
        swiftSources = ['framework/values_generics/']
    }

    frameworkTest("testStdlibFramework") {
        framework('Stdlib') {
            sources = ['framework/stdlib']
            bitcode = true
        }
        if (cacheTesting == null) fullBitcode = true
        swiftSources = ['framework/stdlib/']
    }

    if (cacheTesting != null && cacheTesting.isDynamic) {
        // testMultipleFrameworks disabled until https://youtrack.jetbrains.com/issue/KT-34262 is fixed.
    } else frameworkTest("testMultipleFrameworks") {
        framework('First') {
            sources = ['framework/multiple/framework1', 'framework/multiple/shared']
            bitcode = true
        }
        framework('Second') {
            sources = ['framework/multiple/framework2', 'framework/multiple/shared']
            bitcode = true
        }
        swiftSources = ['framework/multiple']
    }

    frameworkTest("testMultipleFrameworksStatic") {
         // this test doesn't work with caches.
         if (cacheTesting != null && !runtimeAssertionsPanic) {
            // See https://youtrack.jetbrains.com/issue/KT-34261.
            expectedExitStatus = 134
         }

        framework('FirstStatic') {
            artifact = 'First'
            sources = ['framework/multiple/framework1', 'framework/multiple/shared']
            bitcode = true
            isStatic = true
            opts = ['-Xstatic-framework', "-Xpre-link-caches=enable"]
        }
        framework('SecondStatic') {
            artifact = 'Second'
            sources = ['framework/multiple/framework2', 'framework/multiple/shared']
            bitcode = true
            isStatic = true
            opts = ['-Xstatic-framework', "-Xpre-link-caches=enable"]
        }
        codesign = false
        swiftSources = ['framework/multiple']
    }

    frameworkTest("testGh3343Framework") {
        framework('Gh3343') {
            sources = ['framework/gh3343']
            libraries = ['objcGh3343']
        }
        swiftSources = ['framework/gh3343/']
    }

    frameworkTest("testKt42397Framework") {
        enabled = !project.globalTestArgs.contains('-opt')
        framework("Kt42397") {
            sources = ['framework/kt42397']
        }
        swiftSources = ['framework/kt42397']
    }

    frameworkTest("testKt43517Framework") {
        framework('Kt43517') {
            sources = ['framework/kt43517']
            libraries = ['objcKt43517']
        }
        swiftSources = ['framework/kt43517/']
    }

    frameworkTest("testStackTraceFramework") {
        enabled = !project.globalTestArgs.contains('-opt')
        framework('Stacktrace') {
            sources = ['framework/stacktrace']
            opts = ['-g']
        }
        swiftSources = ['framework/stacktrace/']
    }

    frameworkTest("testStackTraceBridgesFramework") {
        enabled = !project.globalTestArgs.contains('-opt')
        framework('StacktraceBridges') {
            sources = ['framework/stacktraceBridges']
            opts = ['-g']
        }
        swiftSources = ['framework/stacktraceBridges/']
    }


    frameworkTest("testStackTraceByLibbacktraceFramework") {
        enabled = !project.globalTestArgs.contains('-opt')
        framework('StacktraceByLibbacktrace') {
            sources = ['framework/stacktraceByLibbacktrace']
            opts = ['-g', '-Xbinary=sourceInfoType=libbacktrace']
        }
        swiftSources = ['framework/stacktraceByLibbacktrace/']
    }

    frameworkTest("testAbstractInstantiationFramework") {
        framework('AbstractInstantiation') {
            sources = ['framework/abstractInstantiation']
        }
        swiftSources = ['framework/abstractInstantiation/']
        expectedExitStatus = 134
    }

    frameworkTest("testFrameworkBundleId") {
        def currentTarget = project.target.name
        enabled = currentTarget.startsWith("mac")

        framework("Foo") {
            sources = ["framework/bundle_id/main.kt", "framework/bundle_id/lib.kt"]
            opts = ["-Xbinary=bundleVersion=FooBundleVersion", "-Xbinary=bundleShortVersionString=FooBundleShortVersionString"]
        }
        swiftSources = []

        doLast {
            def frameworkPath = "$testOutputFramework/testFrameworkBundleId/$target/Foo.framework"
            def bundleIdPattern = ~"<key>CFBundleIdentifier</key>\n\\s*<string>Foo</string>"
            def bundleShortVersionStringPattern = ~"<key>CFBundleShortVersionString</key>\n\\s*<string>FooBundleShortVersionString</string>"
            def bundleVersionPattern = ~"<key>CFBundleVersion</key>\n\\s*<string>FooBundleVersion</string>"
            def plistContent = file("$frameworkPath/Resources/Info.plist").text
            if (!bundleIdPattern.matcher(plistContent).find()) {
                throw new Error("Unexpected CFBundleIdentifier in Info.plist:\n$plistContent")
            }
            if (!bundleShortVersionStringPattern.matcher(plistContent).find()) {
                throw new Error("Unexpected CFBundleShortVersionString in Info.plist:\n$plistContent")
            }
            if (!bundleVersionPattern.matcher(plistContent).find()) {
                throw new Error("Unexpected CFBundleVersion in Info.plist:\n$plistContent")
            }
        }
    }

    frameworkTest("testForwardDeclarationsFramework") {
        framework('ForwardDeclarations') {
            sources = ['framework/forwardDeclarations']
            libraries = ['frameworkForwardDeclarations']
        }
        swiftSources = ['framework/forwardDeclarations/']
    }

    frameworkTest("testFrameworkUsesFoundationModule") {
        framework("Bar") {
            sources = ["framework/use_foundation_module/framework.kt"]
        }
        swiftSources = []
        doLast {
            def frameworkPath = "$testOutputFramework/testFrameworkUsesFoundationModule/$target/Bar.framework"
            def moduleMapContent = file("$frameworkPath/Modules/module.modulemap").text
            def useFoundationPattern = ~"use Foundation"
            if (!useFoundationPattern.matcher(moduleMapContent).find()) {
                throw new Error("Expected use of Foundation module:\n$moduleMapContent")
            }
        }
    }

    frameworkTest("testKt56233Framework") {
        framework("Kt56233") {
            sources = ['framework/kt56233']
        }
        swiftSources = ['framework/kt56233']
    }

    frameworkTest("testKt57791Framework") {
        framework("Kt57791") {
            sources = ['framework/kt57791']
        }
        swiftSources = ['framework/kt57791']
    }

    frameworkTest("testPermanentObjectsFramework") {
        enabled = !isNoopGC // Requires gc to actually happen.
        framework("PermanentObjects") {
            sources = ['framework/permanentObjects']
            opts = ['-opt-in=kotlin.native.internal.InternalForKotlinNative']
        }
        swiftSources = ['framework/permanentObjects']
    }
}

/**
 * Creates tasks to build and execute Harmony regex tests with GTEST logger.
 */
KotlinNativeTestKt.createTest(project, 'harmonyRegexTest', KonanGTest) { task ->
    task.enabled = !isAggressiveGC // TODO: Investigate why too slow
    task.useFilter = false
    task.testLogger = KonanTest.Logger.GTEST

    def sources = UtilsKt.getFilesToCompile(project, ["../../../libraries/stdlib/native-wasm/test/harmony_regex"], [])

    konanArtifacts {
        program('harmonyRegexTest', targets: [target.name]) {
            srcFiles sources
            baseDir "$testOutputStdlib/harmonyRegexTest"
            extraOpts '-tr'
            extraOpts project.globalTestArgs
        }
    }
}

if (UtilsKt.getTestTargetSupportsCodeCoverage(project)) {
    tasks.register("coverage_basic_program", CoverageTest) {

        binaryName = "CoverageBasic"
        numberOfCoveredFunctions = 1
        numberOfCoveredLines = 3

        konanArtifacts {
            program(binaryName, targets: [ target ]) {
                srcDir 'coverage/basic/program'
                baseDir "$testOutputCoverage/$binaryName"
                entryPoint "coverage.basic.program.main"
                extraOpts "-Xcoverage", "-Xcoverage-file=$profrawFile"
                extraOpts project.globalTestArgs
            }
        }
    }

    tasks.register("coverage_basic_library", CoverageTest) {

        binaryName = "CoverageBasicLibrary"
        numberOfCoveredFunctions = 1
        numberOfCoveredLines = 1

        konanArtifacts {
            library("lib_to_cover", targets: [target.name]) {
                srcFiles 'coverage/basic/library/library.kt'
            }
            program(binaryName, targets: [ target ]) {
                srcFiles 'coverage/basic/library/main.kt'
                libraries {
                    artifact konanArtifacts.lib_to_cover
                }
                baseDir "$testOutputCoverage/$binaryName"
                entryPoint "coverage.basic.library.main"
                extraOpts "-Xcoverage-file=$profrawFile", "-Xlibrary-to-cover=${konanArtifacts.lib_to_cover.getArtifactByTarget(target.name)}"
                extraOpts project.globalTestArgs
            }
        }
    }

    tasks.register("coverage_controlflow", CoverageTest) {
        binaryName = "CoverageControlFlow"
        numberOfCoveredFunctions = 1
        numberOfCoveredLines = 102

        konanArtifacts {
            program(binaryName, targets: [ target ]) {
                srcDir 'coverage/basic/controlflow'
                baseDir "$testOutputCoverage/$binaryName"
                entryPoint "coverage.basic.controlflow.main"
                extraOpts "-Xcoverage", "-Xcoverage-file=$profrawFile"
                extraOpts project.globalTestArgs
            }
        }
    }

    tasks.register("coverage_jumps", CoverageTest) {
        binaryName = "CoverageJumps"
        numberOfCoveredFunctions = 8
        numberOfCoveredLines = 74

        konanArtifacts {
            program(binaryName, targets: [ target ]) {
                srcDir 'coverage/basic/jumps'
                baseDir "$testOutputCoverage/$binaryName"
                entryPoint "coverage.basic.jumps.main"
                extraOpts "-Xcoverage", "-Xcoverage-file=$profrawFile"
                extraOpts project.globalTestArgs
            }
        }
    }

    tasks.register("coverage_smoke0", CoverageTest) {
        binaryName = "CoverageSmoke0"
        numberOfCoveredFunctions = 2
        numberOfCoveredLines = 5

        konanArtifacts {
            program(binaryName, targets: [ target ]) {
                srcDir 'coverage/basic/smoke0'
                baseDir "$testOutputCoverage/$binaryName"
                entryPoint "coverage.basic.smoke0.main"
                extraOpts "-Xcoverage", "-Xcoverage-file=$profrawFile"
                extraOpts project.globalTestArgs
            }
        }
    }

    tasks.register("coverage_smoke1", CoverageTest) {
        binaryName = "CoverageSmoke1"
        numberOfCoveredFunctions = 9
        numberOfCoveredLines = 33

        konanArtifacts {
            program(binaryName, targets: [ target ]) {
                srcDir 'coverage/basic/smoke1'
                baseDir "$testOutputCoverage/$binaryName"
                entryPoint "coverage.basic.smoke1.main"
                extraOpts "-Xcoverage", "-Xcoverage-file=$profrawFile"
                extraOpts project.globalTestArgs
            }
        }
    }
}

standaloneTest("local_ea_arraysfieldwrite") {
    disabled = (cacheTesting != null) // Cache is not compatible with -opt.
    useGoldenData = true
    flags = ["-opt"]
    source = "codegen/localEscapeAnalysis/arraysFieldWrite.kt"
}

tasks.register("override_konan_properties0", KonanDriverTest) {
    disabled = isAggressiveGC // No need to test with different GC schedulers
    def overrides = PlatformInfo.isWindows()
            ? '-Xoverride-konan-properties="llvmInlineThreshold=76"'
            : '-Xoverride-konan-properties=llvmInlineThreshold=76'
    flags = [
            "-opt",
            "-Xverbose-phases=MandatoryBitcodeLLVMPostprocessingPhase",
            overrides
    ]
    compilerMessages = true
    source = "link/ir_providers/hello.kt"
    def messages = "inline_threshold: 76\nhello\n"
    outputChecker = { out ->
        messages.split("\n")
                .collect { line -> out.contains(line) }
                .every { it == true }
    }
}

tasks.register("llvm_variant_dev", KonanDriverTest) {
    // We use clang from Xcode on macOS for apple targets,
    // so it is hard to reliably detect LLVM variant for these targets.
    disabled = isAppleTarget(project)
        || isAggressiveGC // No need to test with different GC schedulers
    flags = [
            "-Xllvm-variant=dev",
            "-Xverbose-phases=ObjectFiles"
    ]
    compilerMessages = true
    source = "link/ir_providers/hello.kt"
    // User LLVM variant has "essentials" suffix.
    def message = "-essentials"
    outputChecker = { out -> !out.contains(message) }
}

/**
 * Builds tests into a single binary with TestRunner
 */
task buildKonanTests { t ->
    def compileList = [ "codegen", "datagen", "lower", "runtime", "serialization", "sanity" ]

    // These tests should not be built into the TestRunner's test executable
    def excludeList = [ "codegen/inline/returnLocalClassFromBlock.kt" ]
    project.tasks
            .withType(KonanStandaloneTest.class)
            .each {
                // add library and source files
                if (it instanceof KonanLinkTest) {
                    excludeList += it.lib
                }
                if (it.source != null) {
                    excludeList += it.source
                }
            }
    def sources = UtilsKt.getFilesToCompile(project, compileList, excludeList)

    konanArtifacts {
        program('localTest', targets: [target.name]) {
            srcFiles sources
            baseDir testOutputLocal
            extraOpts '-ea' // Without this option assertions would remain inactive.
            extraOpts '-tr'
            extraOpts '-Xverify-ir=error'
            extraOpts project.globalTestArgs
        }
    }

    // Set build dependencies.
    dependsOn compileKonanLocalTest
    def buildTask = UtilsKt.findKonanBuildTask(project, "localTest", target)
    UtilsKt.dependsOnDist(buildTask)

    // Local tests build into a single binary should depend on this task
    project.tasks
            .withType(KonanLocalTest.class)
            .matching { !(it instanceof KonanStandaloneTest) }
            .configureEach { it.dependsOn(t) }
}


sourceSets {
    nopPlugin {
        kotlin {
            srcDir 'extensions/nop/src/main/kotlin'
        }
    }
}

compileNopPluginKotlin {
    kotlinOptions.freeCompilerArgs += ['-Xskip-prerelease-check']
}

Task pluginTest(String name, String pluginName, Closure configureClosure) {
    def jarTask = project.tasks.register("jar-$pluginName", Jar) {
        it.dependsOn("compile${pluginName.capitalize()}Kotlin")
        from {
            sourceSets[pluginName].output
        }
        archiveBaseName = pluginName
        destinationDirectory = buildDir
    }
    def taskName = "$name-with-$pluginName"
    return KotlinNativeTestKt.createTest(project, taskName, KonanStandaloneTest) { task ->
        task.configure(configureClosure)
        task.dependsOn(jarTask)
        if (task.enabled) {
            konanArtifacts {
                program(taskName, targets: [target.name]) {
                    baseDir   "$testOutputLocal/$taskName"
                    srcFiles  task.getSources()
                    extraOpts task.flags + "-Xplugin=$buildDir/nop-plugin.jar"
                    extraOpts project.globalTestArgs
                }
            }
        }
    }
}

pluginTest("runtime_basic_init", "nopPlugin") {
    source = "runtime/basic/runtime_basic_init.kt"
    flags = ["-tr"]
}


Task fileCheckTest(String name, Closure<FileCheckTest> configureClosure) {
    return project.tasks.create(name, FileCheckTest) { task ->
        task.configure(configureClosure)
        task.llvmIr = project.file("$testOutputFileCheck/$name/$target/out.${task.phaseToCheck}.ll")

        KonanTarget target = task.target
        boolean isCrossCompiling = target != project.target

        // Bitcode that is generated in presence of caches or two-stage compilation differs from the "closed world"-generated,
        // so disable these tests for now.
        if (task.enabled && twoStageEnabled)
            task.enabled = false

        if (task.enabled) {
            konanArtifacts {
                def lib = task.interop
                if (lib != null) {
                    UtilsKt.dependsOnKonanBuildingTask(task, lib, target)
                }
                if (!task.generateFramework) {
                    // We could use `bitcode` here to make things faster. But:
                    // 1. `bitcode` has no other usages.
                    // 2. Unification should help porting to the new test infra.
                    // 3. Compiler might behave differently when outputting bitcode instead of object files.
                    program(name, targets: [target]) {
                        srcFiles task.annotatedSource
                        baseDir "$testOutputFileCheck/$name"
                        if (!isCrossCompiling) {
                            extraOpts project.globalTestArgs
                        }
                        extraOpts task.extraOpts
                        extraOpts "-Xsave-llvm-ir-directory=$testOutputFileCheck/$name/$target"
                        extraOpts "-Xsave-llvm-ir-after=${task.phaseToCheck}"
                        if (lib != null) {
                            libraries {
                                artifact lib
                            }
                        }
                    }
                } else {
                    // Framework support is much weakier than `frameworkTest`, but we don't need much.
                    framework(name, targets: [target]) {
                        srcFiles task.annotatedSource
                        baseDir "$testOutputFileCheck/$name"
                        if (!isCrossCompiling) {
                            extraOpts project.globalTestArgs
                        }
                        extraOpts "-Xsave-llvm-ir-directory=$testOutputFileCheck/$name/$target"
                        extraOpts "-Xsave-llvm-ir-after=${task.phaseToCheck}"

                        if (lib != null) {
                            libraries {
                                artifact lib
                            }
                        }
                    }
                }
                UtilsKt.dependsOnKonanBuildingTask(task, name, target)
            }
        }
    }
}

fileCheckTest("filecheck_smoke0") {
    annotatedSource = project.file('filecheck/smoke0.kt')
}

fileCheckTest("filecheck_when") {
    annotatedSource = project.file('filecheck/when.kt')
}

if (HostManager.@Companion.hostIsMac) {
    fileCheckTest("filecheck_force_arm_instruction_set") {
        enabled = enabled && cacheTesting == null
        annotatedSource = project.file('filecheck/force_arm_instruction_set.kt')
        targetName = "watchos_arm32"
        // Perform check after optimization pipeline because
        // LLVM might infer attributes.
        phaseToCheck = "LTOBitcodeOptimization"
    }

    fileCheckTest("filecheck_redundant_safepoints_removal_smallbinary") {
        enabled = project.globalTestArgs.contains("-opt")
        annotatedSource = project.file('filecheck/redundant_safepoints.kt')
        targetName = "watchos_arm32"
        checkPrefix = "CHECK-SMALLBINARY"
        extraOpts = ["-opt"]
        phaseToCheck = "RemoveRedundantSafepoints"
    }

}

fileCheckTest("filecheck_redundant_safepoints_removal") {
    enabled = !isNoopGC && !isSTWMSGC &&
            project.globalTestArgs.contains("-opt") &&
            !needSmallBinary(project)
    annotatedSource = project.file('filecheck/redundant_safepoints.kt')
    phaseToCheck = "RemoveRedundantSafepoints"
}

fileCheckTest("filecheck_replace_invoke_with_call") {
    annotatedSource = project.file('filecheck/replace_invoke_with_call.kt')
}

fileCheckTest("filecheck_no_frame_on_constant_object_access") {
    annotatedSource = project.file('filecheck/no_frame_on_constant_object_access.kt')
    enabled = project.globalTestArgs.contains('-opt')
}

fileCheckTest("filecheck_kt49847_simple_function_reference") {
    annotatedSource = project.file('filecheck/kt49847_simple_function_reference.kt')
    enabled = project.globalTestArgs.contains('-opt')
}

fileCheckTest("filecheck_kt49847_sam_Any") {
    annotatedSource = project.file('filecheck/kt49847_sam_Any.kt')
    enabled = project.globalTestArgs.contains('-opt')
}

fileCheckTest("filecheck_kt49847_sam_Int") {
    annotatedSource = project.file('filecheck/kt49847_sam_Int.kt')
    enabled = project.globalTestArgs.contains('-opt')
}

fileCheckTest("filecheck_kt49847_sam_Any_generic") {
    annotatedSource = project.file('filecheck/kt49847_sam_Any_generic.kt')
    enabled = project.globalTestArgs.contains('-opt')
}

fileCheckTest("filecheck_kt49847_sam_Int_generic") {
    annotatedSource = project.file('filecheck/kt49847_sam_Int_generic.kt')
    enabled = project.globalTestArgs.contains('-opt')
}

fileCheckTest("filecheck_kt49847_class") {
    annotatedSource = project.file('filecheck/kt49847_class.kt')
    enabled = project.globalTestArgs.contains('-opt')
}

fileCheckTest("filecheck_kt49847_generic") {
    annotatedSource = project.file('filecheck/kt49847_generic.kt')
    enabled = project.globalTestArgs.contains('-opt')
}

fileCheckTest("filecheck_kt49847_generic_receiver") {
    annotatedSource = project.file('filecheck/kt49847_generic_receiver.kt')
    enabled = project.globalTestArgs.contains('-opt')
}

fileCheckTest("filecheck_kt58654") {
    annotatedSource = project.file('filecheck/kt58654.kt')
    enabled = project.globalTestArgs.contains('-opt')
}

fileCheckTest("filecheck_kt53261_inline_unbox") {
    annotatedSource = project.file('filecheck/kt53261/kt53261_inline_unbox.kt')
    enabled = project.globalTestArgs.contains('-opt')
    if (isAppleTarget(project)) {
        checkPrefix = "CHECK-APPLE"
    }
}

fileCheckTest("filecheck_kt53261_noinline_value_unbox") {
    annotatedSource = project.file('filecheck/kt53261/kt53261_noinline_value_unbox.kt')
    enabled = project.globalTestArgs.contains('-opt')
}

fileCheckTest("filecheck_kt53261_noinline_CPointer.kt") {
    annotatedSource = project.file('filecheck/kt53261/kt53261_noinline_CPointer.kt')
    enabled = project.globalTestArgs.contains('-opt')
}

fileCheckTest("filecheck_kt53261_noinline_NativePointed.kt") {
    annotatedSource = project.file('filecheck/kt53261/kt53261_noinline_NativePointed.kt')
    enabled = project.globalTestArgs.contains('-opt')
}

fileCheckTest("filecheck_kt53261_noinline_NonNullNativePtr.kt") {
    annotatedSource = project.file('filecheck/kt53261/kt53261_noinline_NonNullNativePtr.kt')
    enabled = project.globalTestArgs.contains('-opt')
}

fileCheckTest("filecheck_kt53261_noinline_StableRef") {
    annotatedSource = project.file('filecheck/kt53261/kt53261_noinline_StableRef.kt')
    enabled = project.globalTestArgs.contains('-opt')
}

fileCheckTest("filecheck_kt53261_noinline_UByteArray.kt") {
    annotatedSource = project.file('filecheck/kt53261/kt53261_noinline_UByteArray.kt')
    enabled = project.globalTestArgs.contains('-opt')
}

fileCheckTest("filecheck_kt53261_noinline_UIntArray.kt") {
    annotatedSource = project.file('filecheck/kt53261/kt53261_noinline_UIntArray.kt')
    enabled = project.globalTestArgs.contains('-opt')
}

fileCheckTest("filecheck_kt53261_noinline_ULongArray.kt") {
    annotatedSource = project.file('filecheck/kt53261/kt53261_noinline_ULongArray.kt')
    enabled = project.globalTestArgs.contains('-opt')
}

fileCheckTest("filecheck_kt53261_noinline_UShortArray.kt") {
    annotatedSource = project.file('filecheck/kt53261/kt53261_noinline_UShortArray.kt')
    enabled = project.globalTestArgs.contains('-opt')
}

fileCheckTest("filecheck_intrinsics") {
    annotatedSource = project.file('filecheck/intrinsics.kt')
}

fileCheckTest("filecheck_default_parameters_dont_box") {
    annotatedSource = project.file('filecheck/default_parameters_dont_box.kt')
}

tasks.register("kt53119_side_effect", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/stringConcatenationTypeNarrowing/kt53119_side_effect.kt"
}

fileCheckTest("filecheck_kt53119_plus_generated_noescape") {
    annotatedSource = project.file('codegen/stringConcatenationTypeNarrowing/kt53119_plus_generated_noescape.kt')
    enabled = project.globalTestArgs.contains('-opt')
    extraOpts = ["-tr"]
}

tasks.register("kt53119_plus_generated_noescape", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/stringConcatenationTypeNarrowing/kt53119_plus_generated_noescape.kt"
}

fileCheckTest("filecheck_kt53119_plus_member") {
    annotatedSource = project.file('codegen/stringConcatenationTypeNarrowing/kt53119_plus_member.kt')
    enabled = project.globalTestArgs.contains('-opt')
    extraOpts = ["-tr"]
}

tasks.register("kt53119_plus_member", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/stringConcatenationTypeNarrowing/kt53119_plus_member.kt"
}

fileCheckTest("filecheck_kt53119_plus_extension") {
    annotatedSource = project.file('codegen/stringConcatenationTypeNarrowing/kt53119_plus_extension.kt')
    enabled = project.globalTestArgs.contains('-opt')
    extraOpts = ["-tr"]
}

tasks.register("kt53119_plus_extension", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/stringConcatenationTypeNarrowing/kt53119_plus_extension.kt"
}

fileCheckTest("filecheck_kt53119_append_generated") {
    annotatedSource = project.file('codegen/stringConcatenationTypeNarrowing/kt53119_append_generated.kt')
    enabled = project.globalTestArgs.contains('-opt')
    extraOpts = ["-tr"]
}

tasks.register("kt53119_append_generated", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/stringConcatenationTypeNarrowing/kt53119_append_generated.kt"
}

fileCheckTest("filecheck_kt53119_append_manual") {
    annotatedSource = project.file('codegen/stringConcatenationTypeNarrowing/kt53119_append_manual.kt')
    enabled = project.globalTestArgs.contains('-opt')
    extraOpts = ["-tr"]
}

tasks.register("kt53119_append_manual", KonanLocalTest) {
    useGoldenData = true
    source = "codegen/stringConcatenationTypeNarrowing/kt53119_append_manual.kt"
}

fileCheckTest("filecheck_escape_analysis_enabled") {
    annotatedSource = project.file('filecheck/escape_analysis.kt')
    enabled = project.globalTestArgs.contains('-opt')
    checkPrefix = "CHECK-OPT"
}

fileCheckTest("filecheck_enum_when") {
    // In case of `-opt` we inline Enum.ordinal due to property inlining.
    if (project.globalTestArgs.contains('-opt')) {
        checkPrefix = "CHECK-OPT"
    }
    annotatedSource = project.file('filecheck/enum_when.kt')
}

fileCheckTest("filecheck_escape_analysis_disabled") {
    annotatedSource = project.file('filecheck/escape_analysis.kt')
    enabled = project.globalTestArgs.contains('-g')
    checkPrefix = "CHECK-DEBUG"
}

fileCheckTest("filecheck_suspend_returnNothing") {
    annotatedSource = project.file('filecheck/suspend_returnNothing.kt')
}

fileCheckTest("filecheck_suspend_tailcalls_functions") {
    annotatedSource = project.file('filecheck/suspend_tailcalls_functions.kt')
}

fileCheckTest("filecheck_suspend_tailcalls_lambdas") {
    annotatedSource = project.file('filecheck/suspend_tailcalls_lambdas.kt')
}

fileCheckTest("filecheck_bce") {
    enabled = enabled && cacheTesting == null
    annotatedSource = project.file('filecheck/bce.kt')
}

fileCheckTest("filecheck_generic_function_references") {
    enabled = project.globalTestArgs.contains('-opt')
    annotatedSource = project.file('filecheck/generic_function_references.kt')
}

fileCheckTest("filecheck_adopted_function_reference") {
    annotatedSource = project.file('filecheck/adopted_function_reference.kt')
}

fileCheckTest("filecheck_single_tls_load") {
    enabled = project.globalTestArgs.contains("-opt")
    annotatedSource = project.file('filecheck/single_tls_load.kt')
    phaseToCheck = "OptimizeTLSDataLoads"
}

fileCheckTest("filecheck_signext_zeroext0") {
    annotatedSource = project.file('filecheck/signext_zeroext0.kt')
    if (project.testTarget == 'mingw_x64') {
        checkPrefix = "CHECK-WINDOWSX64"
    } else if (!target.family.appleFamily && target.architecture == Architecture.ARM64) {
        checkPrefix = "CHECK-AAPCS"
    }
}

createInterop("filecheck_signext_zeroext_interop_input") {
    it.defFile 'filecheck/signext_zeroext_interop_input.def'
}

fileCheckTest("filecheck_signext_zeroext_interop") {
    enabled = enabled && cacheTesting == null
    annotatedSource = project.file('filecheck/signext_zeroext_interop.kt')
    interop = "filecheck_signext_zeroext_interop_input"
    if (project.testTarget == 'mingw_x64') {
        checkPrefix = "CHECK-WINDOWSX64"
    } else if (!target.family.appleFamily && target.architecture == Architecture.ARM64) {
        checkPrefix = "CHECK-AAPCS"
    }
}

fileCheckTest("filecheck_signext_zeroext_objc_export") {
    annotatedSource = project.file('filecheck/signext_zeroext_objc_export.kt')
    generateFramework = true
//    enabled = target.family.appleFamily
    enabled = false // KT-58863
}

fileCheckTest("filecheck_function_attributes_at_callsite") {
    // attributes for caller and callee might be the same so we allow overlapping.
    additionalFileCheckFlags = ["--allow-deprecated-dag-overlap"]
    annotatedSource = project.file('filecheck/function_attributes_at_callsite.kt')
}

fileCheckTest("filecheck_constants_merge") {
    annotatedSource = project.file('filecheck/constants_merge.kt')
}


fileCheckTest("filecheck_objc_direct") {
    enabled = enabled && cacheTesting == null
    annotatedSource = project.file('filecheck/objc_direct.kt')
    interop = "objcDirect"
    enabled = target.family.appleFamily
}


dependencies {
    nopPluginApi kotlinCompilerModule
    nopPluginApi project(":native:kotlin-native-utils")
    nopPluginApi project(":core:descriptors")
    nopPluginApi project(":compiler:ir.tree")
    nopPluginApi project(":compiler:ir.backend.common")
    nopPluginApi project(":compiler:util")
    nopPluginApi project(":native:frontend.native")
    nopPluginApi project(":compiler:cli-common")
    nopPluginApi project(":compiler:cli-base")
    nopPluginApi project(":compiler:cli")
    nopPluginApi project(":kotlin-util-klib")
    nopPluginApi project(":kotlin-util-klib-metadata")
    nopPluginApi project(":compiler:ir.serialization.common")

    implementation kotlinCompilerModule
    api project(path: ':kotlin-native:backend.native', configuration: 'cli_bcApiElements')
    api RepoDependencies.commonDependency(project, "junit")
}

// Configure build for iOS device targets.
if (UtilsKt.supportsRunningTestsOnDevice(target) && !UtilsKt.getCompileOnlyTests(project)) {
    project.tasks
            .withType(KonanTestExecutable.class)
            .configureEach {
                ExecutorServiceKt.configureXcodeBuild((KonanTestExecutable) it)
            }
    // Exclude tasks that cannot be run on device
    project.tasks
            .withType(KonanTest.class)
            .matching { (it instanceof KonanLocalTest && ((KonanLocalTest) it).useTestData) ||
                    // Filter out tests that depend on libs. TODO: copy them too
                    it instanceof KonanInteropTest ||
                    it instanceof KonanDynamicTest ||
                    it instanceof KonanLinkTest
            }
            .configureEach { it.enabled = false }
}

project.afterEvaluate {
    // Don't treat any task as up-to-date, no matter what.
    // Note: this project should contain only test tasks, including ones that build binaries,
    // and ones that run binaries.
    // So the configuration below mostly means "tests aren't up-to-date".
    tasks.configureEach {
        outputs.upToDateWhen { false }
    }
}