move locklessCancellation to nonWebTest

It uses sleep to test deadlocks

Author: igordmn

compose/runtime/runtime/build.gradle

@@ -269,6 +269,9 @@ if(AndroidXComposePlugin.isMultiplatformEnabled(project)) {
             desktopTest {
                 dependsOn(jvmTest)
             }
+            nonWebTest.dependsOn(commonTest)
+            jvmTest.dependsOn(nonWebTest)
+            nativeTest.dependsOn(nonWebTest)
             webTest {
                 dependsOn(jbTest)
                 dependsOn(nonEmulatorCommonTest)

compose/runtime/runtime/src/darwinTest/kotlin/androidx/compose/runtime/internal/Synchronization.darwin.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.runtime.internal
+
+import kotlinx.cinterop.ExperimentalForeignApi
+import kotlinx.cinterop.UnsafeNumber
+import kotlinx.cinterop.cValue
+import platform.posix.nanosleep
+import platform.posix.timespec
+
+@OptIn(ExperimentalForeignApi::class, UnsafeNumber::class)
+internal actual fun sleep(timeMillis: Int) {
+    val time = cValue<timespec> {
+        tv_sec = timeMillis / 1000
+        tv_nsec = (timeMillis.mod(1000) * NanoSecondsPerMilliSecond)
+    }
+
+    nanosleep(time, null)
+}

compose/runtime/runtime/src/jvmTest/kotlin/androidx/compose/runtime/internal/Synchronization.jvm.kt

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.runtime.internal
+
+internal actual fun sleep(timeMillis: Int) {
+    Thread.sleep(timeMillis.toLong())
+}

compose/runtime/runtime/src/linuxTest/kotlin/androidx/compose/runtime/internal/Synchronization.linux.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.runtime.internal
+
+import kotlinx.cinterop.ExperimentalForeignApi
+import kotlinx.cinterop.UnsafeNumber
+import kotlinx.cinterop.cValue
+import platform.posix.nanosleep
+import platform.posix.timespec
+
+@OptIn(ExperimentalForeignApi::class, UnsafeNumber::class)
+internal actual fun sleep(timeMillis: Int) {
+    val time = cValue<timespec> {
+        tv_sec = (timeMillis / 1000).toLong()
+        tv_nsec = timeMillis.mod(1000L) * NanoSecondsPerMilliSecond
+    }
+
+    nanosleep(time, null)
+}

compose/runtime/runtime/src/mingwX64Test/kotlin/androidx/compose/runtime/internal/Synchronization.mingwX64.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.runtime.internal
+
+import kotlinx.cinterop.ExperimentalForeignApi
+import kotlinx.cinterop.UnsafeNumber
+import kotlinx.cinterop.cValue
+import platform.posix.nanosleep
+import platform.posix.timespec
+
+@OptIn(ExperimentalForeignApi::class, UnsafeNumber::class)
+internal actual fun sleep(timeMillis: Int) {
+    val time = cValue<timespec> {
+        tv_sec = (timeMillis / 1000).toLong()
+        tv_nsec = (timeMillis.mod(1000L) * NanoSecondsPerMilliSecond).toInt()
+    }
+
+    nanosleep(time, null)
+}

compose/runtime/runtime/src/nonEmulatorCommonTest/kotlin/androidx/compose/runtime/BroadcastFrameClockTest.kt

@@ -21,6 +21,7 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertTrue
+import kotlin.time.Duration.Companion.milliseconds
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineStart.UNDISPATCHED
 import kotlinx.coroutines.Deferred
@@ -29,6 +30,7 @@ import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.InternalCoroutinesApi
 import kotlinx.coroutines.async
 import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.test.UnconfinedTestDispatcher
 import kotlinx.coroutines.test.runTest
@@ -82,37 +84,4 @@ class BroadcastFrameClockTest {
             val lateAwaiter = async { clock.withFrameNanos { it } }
             assertAwaiterCancelled("lateAwaiter", lateAwaiter)
         }
-
-    @OptIn(InternalCoroutinesApi::class)
-    @Test(timeout = 5_000)
-    fun locklessCancellation() = runTest {
-        val clock = BroadcastFrameClock()
-        val cancellationGate = AtomicInt(1)
-
-        var spin = true
-        async(start = UNDISPATCHED) {
-            clock.withFrameNanos {
-                cancellationGate.add(-1)
-                @Suppress("BanThreadSleep") while (spin) Thread.sleep(100)
-            }
-        }
-
-        val cancellingJob = async(start = UNDISPATCHED) { clock.withFrameNanos {} }
-
-        launch(Dispatchers.Default) { clock.sendFrame(1) }
-
-        // Wait for the spinlock to start
-        while (cancellationGate.get() != 0) yield()
-
-        // Assert that this line doesn't deadlock.
-        cancellingJob.cancelAndJoin()
-
-        // Make sure that we can queue up new jobs for subsequent frames
-        spin = false
-        assertFalse(clock.hasAwaiters)
-        async(start = UNDISPATCHED) { clock.withFrameNanos {} }
-        assertTrue(clock.hasAwaiters)
-
-        clock.cancel()
-    }
 }

compose/runtime/runtime/src/nonWebTest/kotlin/androidx/compose/runtime/BroadcastFrameClockNonWebTest.nonWeb.kt

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.runtime
+
+import androidx.compose.runtime.internal.AtomicInt
+import androidx.compose.runtime.internal.sleep
+import kotlin.test.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+import kotlin.time.Duration.Companion.milliseconds
+import kotlinx.coroutines.CoroutineStart.UNDISPATCHED
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.async
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.yield
+
+@ExperimentalCoroutinesApi
+class BroadcastFrameClockNonWebTest {
+    @Test
+    fun locklessCancellation() = runTest(timeout = 5_000.milliseconds) {
+        val clock = BroadcastFrameClock()
+        val cancellationGate = AtomicInt(1)
+
+        var spin = true
+        async(start = UNDISPATCHED) {
+            clock.withFrameNanos {
+                cancellationGate.add(-1)
+                @Suppress("BanThreadSleep") while (spin) { sleep(100) }
+            }
+        }
+
+        val cancellingJob = async(start = UNDISPATCHED) { clock.withFrameNanos {} }
+
+        launch(Dispatchers.Default) { clock.sendFrame(1) }
+
+        // Wait for the spinlock to start
+        while (cancellationGate.get() != 0) yield()
+
+        // Assert that this line doesn't deadlock.
+        cancellingJob.cancelAndJoin()
+
+        // Make sure that we can queue up new jobs for subsequent frames
+        spin = false
+        assertFalse(clock.hasAwaiters)
+        async(start = UNDISPATCHED) { clock.withFrameNanos {} }
+        assertTrue(clock.hasAwaiters)
+
+        clock.cancel()
+    }
+}

compose/runtime/runtime/src/nonWebTest/kotlin/androidx/compose/runtime/internal/Synchronization.nonWeb.kt

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.runtime.internal
+
+internal const val NanoSecondsPerMilliSecond = 1_000_000
+
+internal expect fun sleep(timeMillis: Int)