fix(android-tests): fix ProgressReporterTest race condition and ignore stale plugin test

- ProgressReporterTest: add yield() after launch{} so collector subscribes
  before emission on SharedFlow(replay=0); use unique taskIds to avoid
  1%-change de-bounce filter blocking repeated emissions
- NativeWorkmanagerPluginTest: @ignore getPlatformVersion test (method
  removed in v1.1.0 plugin refactor)

Author: vietnguyentuan2019

android/src/test/kotlin/dev/brewkits/native_workmanager/NativeWorkmanagerPluginTest.kt

@@ -2,6 +2,7 @@ package dev.brewkits.native_workmanager
 
 import io.flutter.plugin.common.MethodCall
 import io.flutter.plugin.common.MethodChannel
+import org.junit.Ignore
 import org.mockito.Mockito
 import kotlin.test.Test
 
@@ -14,6 +15,7 @@ import kotlin.test.Test
  */
 
 internal class NativeWorkmanagerPluginTest {
+    @Ignore("getPlatformVersion was removed in the v1.1.0 plugin refactor")
     @Test
     fun onMethodCall_getPlatformVersion_returnsExpectedValue() {
         val plugin = NativeWorkmanagerPlugin()

android/src/test/kotlin/dev/brewkits/native_workmanager/ProgressReporterTest.kt

@@ -7,80 +7,66 @@ import kotlinx.coroutines.flow.toList
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.yield
 import org.junit.Assert.*
 import org.junit.Test
 
 /**
  * Unit tests for ProgressReporter.
  *
- * Tests:
- * - Progress reporting with valid values
- * - Progress clamping (0-100)
- * - Message formatting
- * - Step-based progress calculation
- * - Flow emission and collection
- * - Thread safety
+ * NOTE: ProgressReporter uses SharedFlow(replay=0). Tests must yield() after
+ * launching a collector to ensure subscription is active before emitting.
  */
 class ProgressReporterTest {
 
     @Test
     fun `reportProgress emits valid progress update`() = runTest {
-        val taskId = "test-task-1"
+        val taskId = "test-task-progress-1"
         val progress = 50
         val message = "Processing..."
 
-        // Collect first emission
         val job = launch {
             val update = ProgressReporter.progressFlow.first()
-
             assertEquals(taskId, update.taskId)
             assertEquals(progress, update.progress)
             assertEquals(message, update.message)
         }
 
-        // Emit progress
-        ProgressReporter.reportProgress(
-            taskId = taskId,
-            progress = progress,
-            message = message
-        )
+        yield() // Let the collector subscribe before emitting
 
+        ProgressReporter.reportProgress(taskId = taskId, progress = progress, message = message)
         job.join()
     }
 
     @Test
     fun `reportProgress clamps progress to 0-100 range`() = runTest {
-        val taskId = "test-task-2"
+        val taskId = "test-task-clamp-1"
 
-        // Test over 100
         val job1 = launch {
             val update = ProgressReporter.progressFlow.first()
             assertEquals(100, update.progress)
         }
+        yield()
         ProgressReporter.reportProgress(taskId, progress = 150)
         job1.join()
 
-        // Test under 0
+        val taskId2 = "test-task-clamp-2"
         val job2 = launch {
             val update = ProgressReporter.progressFlow.first()
             assertEquals(0, update.progress)
         }
-        ProgressReporter.reportProgress(taskId, progress = -50)
+        yield()
+        ProgressReporter.reportProgress(taskId2, progress = -50)
         job2.join()
     }
 
     @Test
     fun `reportProgress validates progress range`() = runTest {
         try {
-            // This should work (boundary)
-            ProgressReporter.reportProgress("task", progress = 0)
-            ProgressReporter.reportProgress("task", progress = 100)
-
-            // This should clamp but not throw
-            ProgressReporter.reportProgress("task", progress = 101)
-            ProgressReporter.reportProgress("task", progress = -1)
-
-            // If we get here, clamping worked
+            ProgressReporter.reportProgress("task-validate", progress = 0)
+            ProgressReporter.reportProgress("task-validate-b", progress = 100)
+            ProgressReporter.reportProgress("task-validate-c", progress = 101)
+            ProgressReporter.reportProgress("task-validate-d", progress = -1)
             assertTrue(true)
         } catch (e: Exception) {
             fail("Progress should be clamped, not throw: ${e.message}")
@@ -89,76 +75,73 @@ class ProgressReporterTest {
 
     @Test
     fun `reportStep calculates progress correctly`() = runTest {
-        val taskId = "test-task-3"
+        val taskId = "test-task-step-1"
         val totalSteps = 10
 
-        // Test 0%
         val job1 = launch {
             val update = ProgressReporter.progressFlow.first()
             assertEquals(0, update.progress)
             assertEquals(0, update.currentStep)
             assertEquals(totalSteps, update.totalSteps)
         }
+        yield()
         ProgressReporter.reportStep(taskId, currentStep = 0, totalSteps = totalSteps)
         job1.join()
 
-        // Test 50%
+        val taskId2 = "test-task-step-2"
         val job2 = launch {
             val update = ProgressReporter.progressFlow.first()
             assertEquals(50, update.progress)
             assertEquals(5, update.currentStep)
         }
-        ProgressReporter.reportStep(taskId, currentStep = 5, totalSteps = totalSteps)
+        yield()
+        ProgressReporter.reportStep(taskId2, currentStep = 5, totalSteps = totalSteps)
         job2.join()
 
-        // Test 100%
+        val taskId3 = "test-task-step-3"
         val job3 = launch {
             val update = ProgressReporter.progressFlow.first()
             assertEquals(100, update.progress)
             assertEquals(10, update.currentStep)
         }
-        ProgressReporter.reportStep(taskId, currentStep = 10, totalSteps = totalSteps)
+        yield()
+        ProgressReporter.reportStep(taskId3, currentStep = 10, totalSteps = totalSteps)
         job3.join()
     }
 
     @Test
     fun `reportStep handles zero totalSteps gracefully`() = runTest {
-        val taskId = "test-task-4"
+        val taskId = "test-task-zero-steps"
 
         val job = launch {
             val update = ProgressReporter.progressFlow.first()
-            assertEquals(0, update.progress) // Should default to 0
+            assertEquals(0, update.progress)
             assertEquals(5, update.currentStep)
             assertEquals(0, update.totalSteps)
         }
+        yield()
 
-        ProgressReporter.reportStep(
-            taskId = taskId,
-            currentStep = 5,
-            totalSteps = 0 // Invalid but should handle gracefully
-        )
-
+        ProgressReporter.reportStep(taskId = taskId, currentStep = 5, totalSteps = 0)
         job.join()
     }
 
     @Test
     fun `multiple progress updates are emitted in order`() = runTest {
-        val taskId = "test-task-5"
+        val taskId = "test-task-order"
         val progressValues = listOf(0, 25, 50, 75, 100)
 
         val job = launch {
             val updates = ProgressReporter.progressFlow.take(5).toList()
-
             assertEquals(5, updates.size)
             updates.forEachIndexed { index, update ->
                 assertEquals(taskId, update.taskId)
                 assertEquals(progressValues[index], update.progress)
             }
         }
+        yield()
 
-        // Emit multiple progress updates
-        progressValues.forEach { progress ->
-            ProgressReporter.reportProgress(taskId, progress)
+        progressValues.forEach { p ->
+            ProgressReporter.reportProgress(taskId, p)
         }
 
         job.join()
@@ -167,7 +150,7 @@ class ProgressReporterTest {
     @Test
     fun `toMap converts ProgressUpdate correctly`() = runBlocking {
         val update = ProgressReporter.ProgressUpdate(
-            taskId = "test-task-6",
+            taskId = "test-task-tomap",
             progress = 75,
             message = "Processing file",
             currentStep = 3,
@@ -176,7 +159,7 @@ class ProgressReporterTest {
 
         val map = update.toMap()
 
-        assertEquals("test-task-6", map["taskId"])
+        assertEquals("test-task-tomap", map["taskId"])
         assertEquals(75, map["progress"])
         assertEquals("Processing file", map["message"])
         assertEquals(3, map["currentStep"])
@@ -186,7 +169,7 @@ class ProgressReporterTest {
     @Test
     fun `toMap handles null optional fields`() = runBlocking {
         val update = ProgressReporter.ProgressUpdate(
-            taskId = "test-task-7",
+            taskId = "test-task-nullmap",
             progress = 50,
             message = null,
             currentStep = null,
@@ -195,7 +178,7 @@ class ProgressReporterTest {
 
         val map = update.toMap()
 
-        assertEquals("test-task-7", map["taskId"])
+        assertEquals("test-task-nullmap", map["taskId"])
         assertEquals(50, map["progress"])
         assertFalse(map.containsKey("message"))
         assertFalse(map.containsKey("currentStep"))
@@ -204,31 +187,26 @@ class ProgressReporterTest {
 
     @Test
     fun `concurrent progress updates are handled safely`() = runTest {
-        val taskIds = (1..100).map { "task-$it" }
-        val expectedUpdates = 100
+        val count = 100
+        val taskIds = (1..count).map { "concurrent-task-$it" }
 
         val job = launch {
-            val updates = ProgressReporter.progressFlow.take(expectedUpdates).toList()
-            assertEquals(expectedUpdates, updates.size)
-
-            // All task IDs should be present
+            val updates = ProgressReporter.progressFlow.take(count).toList()
+            assertEquals(count, updates.size)
             val receivedIds = updates.map { it.taskId }.toSet()
-            assertEquals(expectedUpdates, receivedIds.size)
+            assertEquals(count, receivedIds.size)
         }
+        yield()
 
-        // Emit from multiple "concurrent" coroutines
         taskIds.forEach { taskId ->
-            launch {
-                ProgressReporter.reportProgress(taskId, progress = 50)
-            }
+            launch { ProgressReporter.reportProgress(taskId, progress = 50) }
         }
 
         job.join()
     }
 
     @Test
     fun `progress message formatting`() = runTest {
-        val taskId = "test-task-8"
         val messages = listOf(
             "Starting...",
             "Processing file 1 of 10",
@@ -238,14 +216,15 @@ class ProgressReporterTest {
 
         val job = launch {
             val updates = ProgressReporter.progressFlow.take(messages.size).toList()
-
             updates.forEachIndexed { index, update ->
                 assertEquals(messages[index], update.message)
             }
         }
+        yield()
 
-        messages.forEach { message ->
-            ProgressReporter.reportProgress(taskId, progress = 25, message = message)
+        // Use unique taskId per message to bypass the 1%-change de-bounce filter
+        messages.forEachIndexed { index, message ->
+            ProgressReporter.reportProgress("msg-task-$index", progress = 25, message = message)
         }
 
         job.join()