[K/N][tests] Migrate interopTest tests ^KT-61259

native/native.tests/testData/standalone/checkers/leakMemoryWithRunningThreadChecked.kt

@@ -0,0 +1,68 @@
+// EXIT_CODE: !0
+// OUTPUT_REGEX: Cannot run checkers when there are 1 alive runtimes at the shutdown.*
+// MODULE: cinterop
+// FILE: leakMemory.def
+---
+void test_RunInNewThread(void (*)());
+
+// FILE: leakMemory.h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test_RunInNewThread(void (*)());
+
+#ifdef __cplusplus
+}
+#endif
+
+// FILE: leakMemory.cpp
+#include "leakMemory.h"
+
+#include <atomic>
+#include <thread>
+
+extern "C" void test_RunInNewThread(void (*f)()) {
+    std::atomic<bool> haveRun(false);
+    std::thread t([f, &haveRun]() {
+        f();
+        haveRun = true;
+        while (true) {}
+    });
+    t.detach();
+    while (!haveRun) {}
+}
+
+// MODULE: main(cinterop)
+// FILE: main.kt
+@file:OptIn(
+    kotlin.experimental.ExperimentalNativeApi::class,
+    kotlin.native.runtime.NativeRuntimeApi::class,
+    kotlinx.cinterop.ExperimentalForeignApi::class
+)
+
+import leakMemory.*
+import kotlin.concurrent.AtomicInt
+import kotlin.native.concurrent.*
+import kotlin.native.Platform
+import kotlin.test.*
+import kotlinx.cinterop.*
+
+val global = AtomicInt(0)
+
+fun ensureInititalized() {
+    // Leak memory
+    StableRef.create(Any())
+    global.value = 1
+}
+
+fun main() {
+    Platform.isMemoryLeakCheckerActive = true
+    kotlin.native.runtime.Debugging.forceCheckedShutdown = true
+    assertTrue(global.value == 0)
+    // Created a thread, made sure Kotlin is initialized there.
+    test_RunInNewThread(staticCFunction(::ensureInititalized))
+    assertTrue(global.value == 1)
+    // Now exiting. With checked shutdown we will fail, complaining there're
+    // unfinished threads with runtimes.
+}

native/native.tests/testData/standalone/checkers/leakMemoryWithRunningThreadUnchecked.kt

@@ -1,4 +1,3 @@
-// TARGET_BACKEND: NATIVE
 // MODULE: cinterop
 // FILE: leakMemoryWithRunningThreadUnchecked.def
 ---
@@ -51,14 +50,12 @@ import kotlinx.cinterop.*
 val global = AtomicInt(0)
 
 fun ensureInititalized() {
-    // Only needed with the legacy MM. TODO: Remove when legacy MM is gone.
-    kotlin.native.initRuntimeIfNeeded()
     // Leak memory
     StableRef.create(Any())
     global.value = 1
 }
 
-fun box(): String {
+fun main() {
     Platform.isMemoryLeakCheckerActive = true
     kotlin.native.runtime.Debugging.forceCheckedShutdown = false
     assertTrue(global.value == 0)
@@ -67,6 +64,4 @@ fun box(): String {
     assertTrue(global.value == 1)
     // Now exiting. With unchecked shutdown, we exit quietly, even though there're
     // unfinished threads with runtimes.
-
-    return "OK"
 }

native/native.tests/testData/standalone/workerSignals.kt

@@ -0,0 +1,73 @@
+// Cross-thread signalling does not work on Windows
+// DISABLE_NATIVE: targetFamily=MINGW
+// MODULE: cinterop
+// FILE: workerSignals.def
+---
+#include <stdint.h>
+void setupSignalHandler(void);
+void signalThread(uint64_t thread, int value);
+int getValue(void);
+
+// FILE: workerSignals.cpp
+#include <cassert>
+#include <cstdint>
+#include <cstring>
+#include <pthread.h>
+#include <signal.h>
+
+namespace {
+
+int pendingValue = 0;
+thread_local int value = 0;
+
+void signalHandler(int signal) {
+    value = pendingValue;
+}
+
+} // namespace
+
+extern "C" void setupSignalHandler(void) {
+    signal(SIGUSR1, &signalHandler);
+}
+
+extern "C" void signalThread(uint64_t thread, int value) {
+    pendingValue = value;
+    pthread_t t = {};
+    memcpy(&t, &thread, sizeof(pthread_t));
+    auto result = pthread_kill(t, SIGUSR1);
+    assert(result == 0);
+}
+
+extern "C" int getValue(void) {
+    return value;
+}
+
+// MODULE: main(cinterop)
+// FILE: main.kt
+@file:OptIn(kotlin.ExperimentalStdlibApi::class, ObsoleteWorkersApi::class, kotlinx.cinterop.ExperimentalForeignApi::class)
+
+import kotlin.native.concurrent.*
+import kotlin.test.*
+import workerSignals.*
+
+const val defaultValue = 0
+const val newValue = 42
+
+fun main() {
+    setupSignalHandler()
+
+    withWorker {
+        val before = execute(TransferMode.SAFE, {}) {
+            getValue()
+        }.result
+        assertEquals(defaultValue, getValue())
+        assertEquals(defaultValue, before)
+
+        signalThread(platformThreadId, newValue)
+        val after = execute(TransferMode.SAFE, {}) {
+            getValue()
+        }.result
+        assertEquals(defaultValue, getValue())
+        assertEquals(newValue, after)
+    }
+}