detox 20.27.7-smoke.0 → 20.31.0

package/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/timers/TimersIdlingResource.kt

@@ -1,43 +1,45 @@
 package com.wix.detox.reactnative.idlingresources.timers
 
+import android.annotation.SuppressLint
 import android.view.Choreographer
 import androidx.test.espresso.IdlingResource
-import com.wix.detox.reactnative.idlingresources.DetoxBaseIdlingResource
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.modules.core.TimingModule
+import com.wix.detox.reactnative.idlingresources.DetoxIdlingResource
+
+private const val BUSY_WINDOW_THRESHOLD = 1500L
 
 class TimersIdlingResource @JvmOverloads constructor(
-        private val interrogationStrategy: IdleInterrogationStrategy,
-        private val getChoreographer: () -> Choreographer = { Choreographer.getInstance() }
-    ) : DetoxBaseIdlingResource(), Choreographer.FrameCallback {
+    reactContext: ReactContext,
+    private val getChoreographer: () -> Choreographer = { Choreographer.getInstance() }
+) : DetoxIdlingResource(), Choreographer.FrameCallback {
 
-    private var callback: IdlingResource.ResourceCallback? = null
+    private val timingModule: TimingModule = reactContext.getNativeModule(TimingModule::class.java)!!
 
     override fun getName(): String = this.javaClass.name
     override fun getDebugName(): String = "timers"
     override fun getBusyHint(): Map<String, Any>? = null
 
     override fun registerIdleTransitionCallback(callback: IdlingResource.ResourceCallback?) {
-        this.callback = callback
+        super.registerIdleTransitionCallback(callback)
         getChoreographer().postFrameCallback(this)
     }
 
+    @SuppressLint("VisibleForTests")
     override fun checkIdle(): Boolean {
-        return interrogationStrategy.isIdleNow().also { result ->
-            if (result) {
-                notifyIdle()
-            } else {
-                getChoreographer().postFrameCallback(this@TimersIdlingResource)
-            }
-        }
-    }
+        val isIdle = !timingModule.hasActiveTimersInRange(BUSY_WINDOW_THRESHOLD)
 
-    override fun doFrame(frameTimeNanos: Long) {
-        callback?.let {
-            isIdleNow
+        if (isIdle) {
+            notifyIdle()
+        } else {
+            getChoreographer().postFrameCallback(this)
         }
+
+        return isIdle
     }
 
-    override fun notifyIdle() {
-        callback?.onTransitionToIdle()
+    override fun doFrame(frameTimeNanos: Long) {
+        isIdleNow
     }
 
     companion object {

package/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/uimodule/UIManagerModuleReflected.kt

@@ -18,20 +18,12 @@ private const val FIELD_NON_BATCHED_OPS_LOCK = "mNonBatchedOperationsLock"
 
 class UIManagerModuleReflected(private val reactContext: ReactContext) {
 
-    fun getUIOpsCount(): Int = (viewCommandOperations()?.size ?: 0)
-    fun getNextUIOpReflected() = viewCommandOperations()?.firstCommandReflected()
-
-    fun nativeViewHierarchyManager(): NativeHierarchyManagerReflected? =
-            getUIOperationQueue()?.let {
-                NativeHierarchyManagerReflected(it)
-            }
-
     fun isRunnablesListEmpty(): Boolean =
         getUIOperationQueue()?.let {
-            synchronized(Reflect.on(it).field(FIELD_DISPATCH_RUNNABLES_LOCK).get())  {
+            synchronized(Reflect.on(it).field(FIELD_DISPATCH_RUNNABLES_LOCK).get()) {
                 Reflect.on(it)
                     .field(FIELD_DISPATCH_RUNNABLES)
-                    .call(METHOD_IS_EMPTY).get<Boolean>()
+                    .call(METHOD_IS_EMPTY).get()
             }
         } ?: true
 
@@ -39,32 +31,32 @@ class UIManagerModuleReflected(private val reactContext: ReactContext) {
         getUIOperationQueue()?.let {
             synchronized(Reflect.on(it).field(FIELD_NON_BATCHED_OPS_LOCK).get()) {
                 Reflect.on(it)
-                        .field(FIELD_NON_BATCHED_OPS)
-                        .call(METHOD_IS_EMPTY).get<Boolean>()
+                    .field(FIELD_NON_BATCHED_OPS)
+                    .call(METHOD_IS_EMPTY).get()
             }
         } ?: true
 
     fun isOperationQueueEmpty(): Boolean =
         getUIOperationQueue()?.let {
-            Reflect.on(it).call(METHOD_IS_EMPTY).get<Boolean>()
+            Reflect.on(it).call(METHOD_IS_EMPTY).get()
         } ?: true
 
     private fun viewCommandOperations(): ViewCommandOpsQueueReflected? =
-            getUIOperationQueue()?.let {
-                ViewCommandOpsQueueReflected(it)
-            }
+        getUIOperationQueue()?.let {
+            ViewCommandOpsQueueReflected(it)
+        }
 
 
     private fun getUIOperationQueue(): UIViewOperationQueue? =
-            try {
-                val uiModuleClass = Class.forName(CLASS_UI_MANAGER_MODULE)
-                Reflect.on(reactContext)
-                        .call(METHOD_GET_NATIVE_MODULE, uiModuleClass)
-                        .call(METHOD_GET_UI_IMPLEMENTATION)
-                        .field(FIELD_UI_OPERATION_QUEUE)
-                        .get()
-            } catch (e: Exception) {
-                Log.e(LOG_TAG, "failed to get $CLASS_UI_MANAGER_MODULE instance ", e)
-                null
-            }
+        try {
+            val uiModuleClass = Class.forName(CLASS_UI_MANAGER_MODULE)
+            Reflect.on(reactContext)
+                .call(METHOD_GET_NATIVE_MODULE, uiModuleClass)
+                .call(METHOD_GET_UI_IMPLEMENTATION)
+                .field(FIELD_UI_OPERATION_QUEUE)
+                .get()
+        } catch (e: Exception) {
+            Log.e(LOG_TAG, "failed to get $CLASS_UI_MANAGER_MODULE instance ", e)
+            null
+        }
 }

package/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/uimodule/UIModuleIdlingResource.kt

@@ -5,7 +5,7 @@ import android.view.Choreographer
 import androidx.test.espresso.IdlingResource.ResourceCallback
 import com.facebook.react.bridge.ReactContext
 import com.wix.detox.reactnative.helpers.RNHelpers
-import com.wix.detox.reactnative.idlingresources.DetoxBaseIdlingResource
+import com.wix.detox.reactnative.idlingresources.DetoxIdlingResource
 import org.joor.ReflectException
 
 /**
@@ -13,11 +13,9 @@ import org.joor.ReflectException
  * Hooks up to React Native internals to grab the pending ui operations from it.
  */
 class UIModuleIdlingResource(private val reactContext: ReactContext)
-    : DetoxBaseIdlingResource(), Choreographer.FrameCallback {
+    : DetoxIdlingResource(), Choreographer.FrameCallback {
 
-    private val rn66workaround = RN66Workaround()
     private val uiManagerModuleReflected = UIManagerModuleReflected(reactContext)
-    private var callback: ResourceCallback? = null
 
     override fun getName(): String = UIModuleIdlingResource::class.java.name
     override fun getDebugName(): String = " ui"
@@ -39,11 +37,7 @@ class UIModuleIdlingResource(private val reactContext: ReactContext)
 
             val runnablesAreEmpty = uiManagerModuleReflected.isRunnablesListEmpty()
             val nonBatchesOpsEmpty = uiManagerModuleReflected.isNonBatchOpsEmpty()
-            var operationQueueEmpty = uiManagerModuleReflected.isOperationQueueEmpty()
-
-            if (!operationQueueEmpty) {
-                operationQueueEmpty = rn66workaround.isScarceUISwitchCommandStuckInQueue(uiManagerModuleReflected)
-            }
+            val operationQueueEmpty = uiManagerModuleReflected.isOperationQueueEmpty()
 
             if (runnablesAreEmpty && nonBatchesOpsEmpty && operationQueueEmpty) {
                 notifyIdle()
@@ -60,8 +54,8 @@ class UIModuleIdlingResource(private val reactContext: ReactContext)
         return true
     }
 
-    override fun registerIdleTransitionCallback(callback: ResourceCallback) {
-        this.callback = callback
+    override fun registerIdleTransitionCallback(callback: ResourceCallback?) {
+        super.registerIdleTransitionCallback(callback)
         Choreographer.getInstance().postFrameCallback(this)
     }
 
@@ -69,12 +63,6 @@ class UIModuleIdlingResource(private val reactContext: ReactContext)
         isIdleNow
     }
 
-    override fun notifyIdle() {
-        callback?.run {
-            onTransitionToIdle()
-        }
-    }
-
     companion object {
         private const val LOG_TAG = "Detox"
     }

package/android/detox/src/testFull/java/com/wix/detox/reactnative/idlingresources/AsyncStorageIdlingResourceTest.kt

@@ -0,0 +1,248 @@
+package com.wix.detox.reactnative.idlingresources
+
+import androidx.test.espresso.IdlingResource
+import com.facebook.react.bridge.NativeModule
+import com.wix.detox.UTHelpers.yieldToOtherThreads
+import com.wix.detox.reactnative.idlingresources.storage.AsyncStorageIdlingResource
+import com.wix.detox.reactnative.idlingresources.storage.SerialExecutorReflected
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.any
+import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.times
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+import org.robolectric.RobolectricTestRunner
+import java.util.concurrent.Executor
+import java.util.concurrent.Executors
+
+private class AsyncStorageModuleStub : NativeModule {
+    val executor: Executor = mock(name = "native-module's executor")
+    override fun getName() = "stub"
+    override fun initialize() {}
+    override fun canOverrideExistingModule() = false
+    override fun onCatalystInstanceDestroy() {}
+    override fun invalidate() {}
+}
+
+@RunWith(RobolectricTestRunner::class)
+class AsyncStorageIdlingResourceTest {
+    private lateinit var sexecutor: Executor
+    private lateinit var sexecutorReflected: SerialExecutorReflected
+    private lateinit var sexecutorReflectedGenFn: (executor: Executor) -> SerialExecutorReflected
+    private lateinit var module: AsyncStorageModuleStub
+    private lateinit var uut: AsyncStorageIdlingResource
+
+    @Before
+    fun setup() {
+        sexecutor = mock()
+        module = AsyncStorageModuleStub()
+        sexecutorReflected = mock() {
+            on { executor() }.thenReturn(sexecutor)
+        }
+        sexecutorReflectedGenFn = mock() {
+            on { invoke(eq(module.executor)) }.thenReturn(sexecutorReflected)
+        }
+
+
+        uut = AsyncStorageIdlingResource(module, sexecutorReflectedGenFn)
+    }
+
+    fun givenNoActiveTasks() = whenever(sexecutorReflected.hasActiveTask()).thenReturn(false)
+    fun givenAnActiveTask() = whenever(sexecutorReflected.hasActiveTask()).thenReturn(true)
+    fun givenNoPendingTasks() = whenever(sexecutorReflected.hasPendingTasks()).thenReturn(false)
+    fun givenPendingTasks() = whenever(sexecutorReflected.hasPendingTasks()).thenReturn(true)
+    fun givenIdleSExecutor() {
+        givenNoActiveTasks()
+        givenNoPendingTasks()
+    }
+
+    fun givenBusySExecutor() {
+        givenAnActiveTask()
+        givenNoPendingTasks()
+    }
+
+    fun verifyNoTasksEnqueued() = verify(sexecutorReflected, never()).executeTask(any())
+    fun verifyTaskEnqueuedOnce() = verify(sexecutorReflected, times(1)).executeTask(any())
+    fun verifyTaskEnqueuedTwice() = verify(sexecutorReflected, times(2)).executeTask(any())
+
+    @Test
+    fun `should have a name`() {
+        assertThat(uut.name).isEqualTo("com.wix.detox.reactnative.idlingresources.storage.AsyncStorageIdlingResource")
+    }
+
+    @Test
+    fun `should have a debug-name`() {
+        assertThat(uut.getDebugName()).isEqualTo("io")
+    }
+
+    @Test
+    fun `should be idle`() {
+        givenIdleSExecutor()
+        assertThat(uut.isIdleNow).isTrue()
+    }
+
+    @Test
+    fun `should be busy if executor is executing`() {
+        givenAnActiveTask()
+        givenNoPendingTasks()
+        assertThat(uut.isIdleNow).isFalse()
+    }
+
+    @Test
+    fun `should be busy if executor has pending tasks`() {
+        givenNoActiveTasks()
+        givenPendingTasks()
+        assertThat(uut.isIdleNow).isFalse()
+    }
+
+    @Test
+    fun `should be synchronized over actual executor`() {
+        val localExecutor = Executors.newSingleThreadExecutor()
+        var isIdle: Boolean? = null
+        synchronized(sexecutor) {
+            localExecutor.submit {
+                isIdle = uut.isIdleNow
+            }
+            yieldToOtherThreads(localExecutor)
+            assertThat(isIdle).isNull()
+        }
+        yieldToOtherThreads(localExecutor)
+    }
+
+    @Test
+    fun `should enqueue an idle-check task if resource is busy`() {
+        givenBusySExecutor()
+        uut.isIdleNow
+        verifyTaskEnqueuedOnce()
+    }
+
+    @Test
+    fun `should not enqueue an idle-check task if resource if idle`() {
+        givenIdleSExecutor()
+        uut.isIdleNow
+        verifyNoTasksEnqueued()
+    }
+
+    @Test
+    fun `should not enqueue more than one idle-check task`() {
+        givenBusySExecutor()
+
+        repeat(2) {
+            uut.isIdleNow
+        }
+        verifyTaskEnqueuedOnce()
+    }
+
+    private val callback: IdlingResource.ResourceCallback = mock()
+
+
+    fun verifyTransitionToIdleCalled() = verify(callback).onTransitionToIdle()
+    fun verifyTransitionToIdleNotCalled() = verify(callback, never()).onTransitionToIdle()
+
+    @Test
+    fun `should enqueue an idle-check task`() {
+        uut.registerIdleTransitionCallback(callback)
+        verifyTaskEnqueuedOnce()
+    }
+
+    @Test
+    fun `callback registration - should be synchronized over actual executor`() {
+        val localExecutor = Executors.newSingleThreadExecutor()
+
+        synchronized(sexecutor) {
+            localExecutor.submit {
+                uut.registerIdleTransitionCallback(callback)
+            }
+            yieldToOtherThreads(localExecutor)
+            verifyNoTasksEnqueued()
+        }
+        yieldToOtherThreads(localExecutor)
+    }
+
+
+    fun executeIdleCheckTask() {
+        argumentCaptor<Runnable>().also {
+            verify(sexecutorReflected).executeTask(it.capture())
+        }.firstValue.run()
+    }
+
+    @Test
+    fun `should transition to idle`() {
+        givenIdleSExecutor()
+
+        uut.registerIdleTransitionCallback(callback)
+        executeIdleCheckTask()
+
+        verifyTransitionToIdleCalled()
+    }
+
+    @Test
+    fun `should not transition to idle if busy`() {
+        givenAnActiveTask()
+        givenPendingTasks()
+
+        uut.registerIdleTransitionCallback(callback)
+        executeIdleCheckTask()
+
+        verifyTransitionToIdleNotCalled()
+    }
+
+    @Test
+    fun `should not inspect sexecutor for activity, because it runs on the executor itself`() {
+        givenAnActiveTask()
+        givenPendingTasks()
+
+        uut.registerIdleTransitionCallback(callback)
+        executeIdleCheckTask()
+
+        verify(sexecutorReflected, never()).hasActiveTask()
+    }
+
+    @Test
+    fun `should reenqueue if still busy`() {
+        givenAnActiveTask()
+        givenPendingTasks()
+
+        uut.registerIdleTransitionCallback(callback)
+        executeIdleCheckTask()
+
+        verifyTaskEnqueuedTwice()
+    }
+
+    @Test
+    fun `should be synchronized`() {
+        val localExecutor = Executors.newSingleThreadExecutor()
+
+        givenIdleSExecutor()
+        uut.registerIdleTransitionCallback(callback)
+
+        synchronized(sexecutor) {
+            localExecutor.submit {
+                executeIdleCheckTask()
+            }
+            yieldToOtherThreads(localExecutor)
+            verifyTransitionToIdleNotCalled()
+        }
+        yieldToOtherThreads(localExecutor)
+    }
+
+
+    @Test
+    fun `should allow for an enqueuing of more tasks after idle-transition`() {
+        uut.registerIdleTransitionCallback(callback)
+
+        givenIdleSExecutor()
+        executeIdleCheckTask()
+
+        givenBusySExecutor()
+        uut.isIdleNow
+
+        verifyTaskEnqueuedTwice()
+    }
+}

package/android/detox/src/testFull/java/com/wix/detox/reactnative/idlingresources/NetworkIdlingResourcesTest.kt

@@ -1,6 +1,7 @@
 package com.wix.detox.reactnative.idlingresources
 
 import com.wix.detox.UTHelpers.yieldToOtherThreads
+import com.wix.detox.reactnative.idlingresources.network.NetworkIdlingResource
 import org.assertj.core.api.Assertions.assertThat
 
 import okhttp3.Dispatcher
@@ -18,7 +19,10 @@ class NetworkIdlingResourcesTest {
     @Before
     fun setup() {
         dispatcher = Dispatcher()
-        uut = NetworkIdlingResource(dispatcher)
+        uut =
+            NetworkIdlingResource(
+                dispatcher
+            )
     }
 
     // Note: Ideally, we should test that the list of busy resources is protected,

package/android/detox/src/testFull/java/com/wix/detox/reactnative/idlingresources/SerialExecutorReflectedSpec.kt

@@ -1,5 +1,6 @@
 package com.wix.detox.reactnative.idlingresources
 
+import com.wix.detox.reactnative.idlingresources.storage.SerialExecutorReflected
 import org.assertj.core.api.Assertions.assertThat
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.verify

package/android/detox/src/testFull/java/com/wix/detox/reactnative/idlingresources/timers/TimersIdlingResourceTest.kt

@@ -0,0 +1,212 @@
+package com.wix.detox.reactnative.idlingresources.timers
+
+import android.view.Choreographer
+import androidx.test.espresso.IdlingResource
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.modules.core.TimingModule
+import org.assertj.core.api.Assertions
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.*
+import org.robolectric.RobolectricTestRunner
+import org.spekframework.spek2.Spek
+import org.spekframework.spek2.style.specification.describe
+
+private fun anIdlingResourceCallback() = mock<IdlingResource.ResourceCallback>()
+
+@RunWith(RobolectricTestRunner::class)
+class TimersIdlingResourceTest {
+    private val choreographer: Choreographer = mock()
+    private val context: ReactContext = mock()
+    private val timersModule: TimingModule = mock()
+    private lateinit var timersIdlingResource: TimersIdlingResource
+
+    @Before
+    fun setup() {
+        whenever(context.getNativeModule(eq(TimingModule::class.java))).thenReturn(timersModule)
+        timersIdlingResource = TimersIdlingResource(context) { choreographer }
+    }
+
+
+    private fun givenIdleStrategy() {
+        whenever(timersModule.hasActiveTimersInRange(any())).thenReturn(false)
+    }
+
+    private fun givenBusyStrategy() {
+        whenever(timersModule.hasActiveTimersInRange(any())).thenReturn(true)
+    }
+
+    private fun getChoreographerCallback(): Choreographer.FrameCallback {
+        argumentCaptor<Choreographer.FrameCallback>().apply {
+            verify(choreographer).postFrameCallback(capture())
+            return firstValue
+        }
+    }
+
+    private fun invokeChoreographerCallback() {
+        getChoreographerCallback().doFrame(0L)
+    }
+
+    @Test
+    fun `should return a debug-name`() {
+        Assertions.assertThat(timersIdlingResource.getDebugName()).isEqualTo("timers")
+    }
+
+    @Test
+    fun `should be idle if strategy says so`() {
+        givenIdleStrategy()
+        Assertions.assertThat(timersIdlingResource.isIdleNow).isTrue()
+    }
+
+    @Test
+    fun `should be busy if strategy says so`() {
+        givenBusyStrategy()
+        Assertions.assertThat(timersIdlingResource.isIdleNow).isFalse()
+    }
+
+    @Test
+    fun `should transition to idle if found idle by strategy`() {
+        givenIdleStrategy()
+
+        val callback = anIdlingResourceCallback()
+
+        with(timersIdlingResource) {
+            registerIdleTransitionCallback(callback)
+            isIdleNow
+        }
+
+        verify(callback).onTransitionToIdle()
+    }
+
+    @Test
+    fun `should NOT transition to idle if found busy by strategy`() {
+        givenBusyStrategy()
+
+        val callback = anIdlingResourceCallback()
+
+        with(timersIdlingResource) {
+            registerIdleTransitionCallback(callback)
+            isIdleNow
+        }
+
+        verify(callback, never()).onTransitionToIdle()
+    }
+
+    @Test
+    fun `should be idle if paused`() {
+        givenBusyStrategy()
+
+        val uut = timersIdlingResource.apply {
+            pause()
+        }
+
+        Assertions.assertThat(uut.isIdleNow).isTrue()
+    }
+
+    @Test
+    fun `should be busy if paused and resumed`() {
+        givenBusyStrategy()
+
+        val uut = timersIdlingResource.apply {
+            pause()
+            resume()
+        }
+
+        Assertions.assertThat(uut.isIdleNow).isFalse()
+    }
+
+    @Test
+    fun `should notify of transition to idle upon pausing`() {
+        givenBusyStrategy()
+
+        val callback = anIdlingResourceCallback()
+
+        with(timersIdlingResource) {
+            registerIdleTransitionCallback(callback)
+            pause()
+        }
+
+        verify(callback).onTransitionToIdle()
+    }
+
+    @Test
+    fun `should enqueue an is-idle check using choreographer when a callback gets registered`() {
+        with(timersIdlingResource) {
+            registerIdleTransitionCallback(mock())
+        }
+
+        verify(choreographer).postFrameCallback(any())
+    }
+
+    @Test
+    fun `should transition to idle when preregistered choreographer is dispatched`() {
+        givenIdleStrategy()
+
+        val callback = anIdlingResourceCallback()
+
+        timersIdlingResource.registerIdleTransitionCallback(callback)
+        invokeChoreographerCallback()
+
+        verify(callback).onTransitionToIdle()
+    }
+
+    @Test
+    fun `should NOT transition to idle if not idle when preregistered choreographer is dispatched`() {
+        givenBusyStrategy()
+
+        val callback = anIdlingResourceCallback()
+
+        timersIdlingResource.registerIdleTransitionCallback(callback)
+        invokeChoreographerCallback()
+
+        verify(callback, never()).onTransitionToIdle()
+    }
+
+    @Test
+    fun `should re-register choreographer if found idle while preregistered choreographer is dispatched`() {
+        givenBusyStrategy()
+
+        val callback = anIdlingResourceCallback()
+
+        val uut = timersIdlingResource
+        uut.registerIdleTransitionCallback(callback)
+        invokeChoreographerCallback()
+
+        verify(choreographer, times(2)).postFrameCallback(any())
+    }
+
+    @Test
+    fun `should adhere to pausing also when invoked via choreographer callback`() {
+        givenBusyStrategy()
+
+        val callback = anIdlingResourceCallback()
+
+        timersIdlingResource.apply {
+            pause()
+            registerIdleTransitionCallback(callback)
+        }
+        val runtimeChoreographerCallback = getChoreographerCallback()
+
+        reset(callback, choreographer)
+        runtimeChoreographerCallback.doFrame(0L)
+
+        verify(callback, never()).onTransitionToIdle()
+        verify(choreographer, never()).postFrameCallback(any())
+    }
+
+    @Test
+    fun `should enqueue an additional idle check (using choreographer) if found busy`() {
+        givenBusyStrategy()
+        timersIdlingResource.isIdleNow
+        verify(choreographer).postFrameCallback(any())
+    }
+
+    @Test
+    fun `should NOT enqueue an additional idle check (using choreographer) if found idle`() {
+        givenIdleStrategy()
+        timersIdlingResource.isIdleNow
+        verify(choreographer, never()).postFrameCallback(any())
+    }
+}
+

package/android/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME