Introduce timeouts in tests for waitForIdle and createComposeWindow (#2718)

## Testing
N/A

## Release Notes
N/A

Author: eymar

compose/ui/ui-test/src/skikoMain/kotlin/androidx/compose/ui/test/ComposeUiTest.skiko.kt

@@ -49,6 +49,8 @@ import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.coroutines.cancellation.CancellationException
 import kotlin.math.roundToInt
 import kotlin.time.Duration
+import kotlin.time.DurationUnit
+import kotlin.time.toDuration
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
@@ -366,7 +368,8 @@ open class SkikoComposeUiTest @InternalTestApi constructor(
     }
 
     override fun waitForIdle() {
-        // TODO: consider adding a timeout to avoid an infinite loop?
+        val startedAt = currentNanoTime().toDuration(DurationUnit.NANOSECONDS)
+        var lastReportedElapsedSeconds = 0L
         // always check even if we are idle
         uncaughtExceptionHandler.throwUncaught()
         while (!isIdle()) {
@@ -375,6 +378,12 @@ open class SkikoComposeUiTest @InternalTestApi constructor(
             if (!areAllResourcesIdle()) {
                 sleep(IDLING_RESOURCES_CHECK_INTERVAL_MS)
             }
+            val currentTime = currentNanoTime().toDuration(DurationUnit.NANOSECONDS)
+            val elapsedSeconds = (currentTime - startedAt).inWholeSeconds
+            if (elapsedSeconds > lastReportedElapsedSeconds) {
+                println("Suspicious! waitForIdle has not finished after $elapsedSeconds seconds.")
+                lastReportedElapsedSeconds = elapsedSeconds
+            }
         }
     }
 

compose/ui/ui/src/webTest/kotlin/androidx/compose/ui/OnCanvasTests.kt

@@ -34,12 +34,15 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.TimeoutCancellationException
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.flow.takeWhile
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.test.TestResult
 import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeout
 import kotlinx.coroutines.yield
 import org.w3c.dom.Element
 import org.w3c.dom.HTMLCanvasElement
@@ -104,13 +107,23 @@ internal interface OnCanvasTests {
     ) {
         ComposeViewport(viewportContainerId = containerId, configure = configure, content = content)
 
-        suspendCoroutine { continuation ->
-            // This helps reduce the flakiness.
-            // A potential cause of flakiness: the default Coroutine Dispatcher regularly postpones
-            // the resumption of the tasks in its queue to the next frame.
-            // (it does so to let the event loop run / release the single thread)
-            // I don't expect any issue from doing this, since a test will suspend and won't do anything.
-            window.requestAnimationFrame { continuation.resumeWith(Result.success(it)) }
+        withContext(Dispatchers.Default) {
+            val timeoutDuration = 1.seconds
+            try {
+                // Using withTimeout here for diagnostic. Some flaky tests fail due to timeout. But there is nothing else except this suspend call.
+                withTimeout(timeoutDuration) {
+                    suspendCoroutine<Unit> { continuation ->
+                        // This helps reduce the flakiness.
+                        // A potential cause of flakiness: the default Coroutine Dispatcher regularly postpones
+                        // the resumption of the tasks in its queue to the next frame.
+                        // (it does so to let the event loop run / release the single thread)
+                        // I don't expect any issue from doing this, since a test will suspend and won't do anything.
+                        window.requestAnimationFrame { continuation.resumeWith(Result.success(Unit)) }
+                    }
+                }
+            } catch (e: TimeoutCancellationException) {
+                throw AssertionError("Timed out ($timeoutDuration) waiting for AnimationFrame", e)
+            }
         }
     }
 
@@ -159,6 +172,18 @@ internal interface OnCanvasTests {
             WebApplicationScope(this).body()
         }
     }
+
+    suspend fun <T> Channel<T>.receiveWithTimeout(timeout: Duration = 2.seconds): T {
+        return withContext(Dispatchers.Default) {
+            try {
+                withTimeout(timeout) {
+                    this@receiveWithTimeout.receive()
+                }
+            } catch (e: TimeoutCancellationException) {
+                throw AssertionError("Timed out ($timeout) waiting for value on channel", e)
+            }
+        }
+    }
 }
 
 internal fun <T> Channel<T>.sendFromScope(value: T, scope: CoroutineScope = MainScope()) {