Get rid of old Kotlin/Native memory model

Fixes #3375

Author: qwwdfsad

kotlinx-coroutines-core/build.gradle

@@ -56,6 +56,7 @@ void defineSourceSet(newName, dependsOn, includedInPred) {
 }
 
 static boolean isNativeDarwin(String name) { return ["ios", "macos", "tvos", "watchos"].any { name.startsWith(it) } }
+
 static boolean isNativeOther(String name) { return ["linux", "mingw"].any { name.startsWith(it) } }
 
 defineSourceSet("concurrent", ["common"]) { it in ["jvm", "native"] }
@@ -77,40 +78,18 @@ kotlin {
     }
 
     /*
-     * Configure four test runs:
-     * 1) Old memory model, Main thread
-     * 2) New memory model, Main thread
-     * 3) Old memory model, BG thread
-     * 4) New memory model, BG thread (required for Dispatchers.Main tests on Darwin)
+     * Configure two test runs:
+     * 1) New memory model, Main thread
+     * 2) New memory model, BG thread (required for Dispatchers.Main tests on Darwin)
      *
      * All new MM targets are build with optimize = true to have stress tests properly run.
      */
     targets.withType(org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTargetWithTests.class).configureEach {
-        binaries {
-            // Test for memory leaks using a special entry point that does not exit but returns from main
-            binaries.getTest("DEBUG").freeCompilerArgs += ["-e", "kotlinx.coroutines.mainNoExit"]
-        }
-
-        binaries.test("newMM", [DEBUG]) {
-            def thisTest = it
-            freeCompilerArgs += ["-e", "kotlinx.coroutines.mainNoExit"]
-            optimized = true
-            binaryOptions["memoryModel"] = "experimental"
-            testRuns.create("newMM") {
-                setExecutionSourceFrom(thisTest)
-                // A hack to get different suffixes in the aggregated report.
-                executionTask.configure { targetName = "$targetName new MM" }
-            }
-        }
-
-        binaries.test("worker",  [DEBUG]) {
-            def thisTest = it
-            freeCompilerArgs += ["-e", "kotlinx.coroutines.mainBackground"]
-            testRuns.create("worker") {
-                setExecutionSourceFrom(thisTest)
-                executionTask.configure { targetName = "$targetName worker" }
-            }
-        }
+        def defaultTests = binaries.getTest("DEBUG")
+        // Test for memory leaks using a special entry point that does not exit but returns from main
+        defaultTests.freeCompilerArgs += ["-e", "kotlinx.coroutines.mainNoExit"]
+        defaultTests.optimized = true
+        defaultTests.binaryOptions["memoryModel"] = "experimental"
 
         binaries.test("workerWithNewMM", [DEBUG]) {
             def thisTest = it
@@ -150,11 +129,11 @@ def configureNativeSourceSetPreset(name, preset) {
     def implementationConfiguration = configurations[hostMainCompilation.defaultSourceSet.implementationMetadataConfigurationName]
     // Now find the libraries: Finds platform libs & stdlib, but platform declarations are still not resolved due to IDE bugs
     def hostNativePlatformLibs = files(
-        provider {
-            implementationConfiguration.findAll {
-                it.path.endsWith(".klib") || it.absolutePath.contains("klib${File.separator}platform") || it.absolutePath.contains("stdlib")
+            provider {
+                implementationConfiguration.findAll {
+                    it.path.endsWith(".klib") || it.absolutePath.contains("klib${File.separator}platform") || it.absolutePath.contains("stdlib")
+                }
             }
-        }
     )
     // Add all those dependencies
     for (suffix in sourceSetSuffixes) {

kotlinx-coroutines-core/concurrent/test/AbstractDispatcherConcurrencyTest.kt

@@ -12,7 +12,7 @@ abstract class AbstractDispatcherConcurrencyTest : TestBase() {
    public abstract val dispatcher: CoroutineDispatcher
 
     @Test
-    fun testLaunchAndJoin() = runMtTest {
+    fun testLaunchAndJoin() = runTest {
         expect(1)
         var capturedMutableState = 0
         val job = GlobalScope.launch(dispatcher) {
@@ -25,7 +25,7 @@ abstract class AbstractDispatcherConcurrencyTest : TestBase() {
     }
 
     @Test
-    fun testDispatcherHasOwnThreads() = runMtTest {
+    fun testDispatcherHasOwnThreads() = runTest {
         val channel = Channel<Int>()
         GlobalScope.launch(dispatcher) {
             channel.send(42)
@@ -41,7 +41,7 @@ abstract class AbstractDispatcherConcurrencyTest : TestBase() {
     }
 
     @Test
-    fun testDelayInDispatcher() = runMtTest {
+    fun testDelayInDispatcher() = runTest {
         expect(1)
         val job = GlobalScope.launch(dispatcher) {
             expect(2)

kotlinx-coroutines-core/concurrent/test/ConcurrentExceptionsStressTest.kt

@@ -22,7 +22,7 @@ class ConcurrentExceptionsStressTest : TestBase() {
     }
 
     @Test
-    fun testStress() = runMtTest {
+    fun testStress() = runTest {
         workers = Array(nWorkers) { index ->
             newSingleThreadContext("JobExceptionsStressTest-$index")
         }

kotlinx-coroutines-core/concurrent/test/JobStructuredJoinStressTest.kt

@@ -16,12 +16,12 @@ class JobStructuredJoinStressTest : TestBase() {
     private val nRepeats = 10_000 * stressTestMultiplier
 
     @Test
-    fun testStressRegularJoin() = runMtTest {
+    fun testStressRegularJoin() = runTest {
         stress(Job::join)
     }
 
     @Test
-    fun testStressSuspendCancellable() = runMtTest {
+    fun testStressSuspendCancellable() = runTest {
         stress { job ->
             suspendCancellableCoroutine { cont ->
                 job.invokeOnCompletion { cont.resume(Unit) }
@@ -30,7 +30,7 @@ class JobStructuredJoinStressTest : TestBase() {
     }
 
     @Test
-    fun testStressSuspendCancellableReusable() = runMtTest {
+    fun testStressSuspendCancellableReusable() = runTest {
         stress { job ->
             suspendCancellableCoroutineReusable { cont ->
                 job.invokeOnCompletion { cont.resume(Unit) }

kotlinx-coroutines-core/concurrent/test/LimitedParallelismConcurrentTest.kt

@@ -23,7 +23,7 @@ class LimitedParallelismConcurrentTest : TestBase() {
     }
 
     @Test
-    fun testLimitedExecutor() = runMtTest {
+    fun testLimitedExecutor() = runTest {
         val executor = newFixedThreadPoolContext(targetParallelism, "test")
         val view = executor.limitedParallelism(targetParallelism)
         doStress {
@@ -45,7 +45,7 @@ class LimitedParallelismConcurrentTest : TestBase() {
     }
 
     @Test
-    fun testTaskFairness() = runMtTest {
+    fun testTaskFairness() = runTest {
         val executor = newSingleThreadContext("test")
         val view = executor.limitedParallelism(1)
         val view2 = executor.limitedParallelism(1)

kotlinx-coroutines-core/concurrent/test/RunBlockingTest.kt

@@ -10,7 +10,7 @@ import kotlin.test.*
 class RunBlockingTest : TestBase() {
 
     @Test
-    fun testWithTimeoutBusyWait() = runMtTest {
+    fun testWithTimeoutBusyWait() = runTest {
         val value = withTimeoutOrNull(10) {
             while (isActive) {
                 // Busy wait
@@ -52,7 +52,7 @@ class RunBlockingTest : TestBase() {
     }
 
     @Test
-    fun testOtherDispatcher() = runMtTest {
+    fun testOtherDispatcher() = runTest {
         expect(1)
         val name = "RunBlockingTest.testOtherDispatcher"
         val thread = newSingleThreadContext(name)
@@ -68,7 +68,7 @@ class RunBlockingTest : TestBase() {
     }
 
     @Test
-    fun testCancellation()  = runMtTest {
+    fun testCancellation()  = runTest {
         newFixedThreadPoolContext(2, "testCancellation").use {
             val job = GlobalScope.launch(it) {
                 runBlocking(coroutineContext) {

kotlinx-coroutines-core/concurrent/test/TestBaseExtension.common.kt

@@ -20,7 +20,7 @@ class BroadcastChannelSubStressTest: TestBase() {
     private val receivedTotal = atomic(0L)
 
     @Test
-    fun testStress() = runMtTest {
+    fun testStress() = runTest {
         TestBroadcastChannelKind.values().forEach { kind ->
             println("--- BroadcastChannelSubStressTest $kind")
             val broadcast = kind.create<Long>()

kotlinx-coroutines-core/concurrent/test/channels/BroadcastChannelSubStressTest.kt

@@ -28,7 +28,7 @@ class ChannelCancelUndeliveredElementStressTest : TestBase() {
     private val dUndeliveredCnt = atomic(0)
 
     @Test
-    fun testStress() = runMtTest {
+    fun testStress() = runTest {
         repeat(repeatTimes) {
             val channel = Channel<Int>(1) { dUndeliveredCnt.incrementAndGet() }
             val j1 = launch(Dispatchers.Default) {

kotlinx-coroutines-core/concurrent/test/channels/ChannelCancelUndeliveredElementStressTest.kt

@@ -22,7 +22,7 @@ class ConflatedBroadcastChannelNotifyStressTest : TestBase() {
     private val receivedTotal = atomic(0)
 
     @Test
-    fun testStressNotify()= runMtTest {
+    fun testStressNotify()= runTest {
         println("--- ConflatedBroadcastChannelNotifyStressTest")
         val senders = List(nSenders) { senderId ->
             launch(Dispatchers.Default + CoroutineName("Sender$senderId")) {