update

Author: hangga

core-kotlin-modules/core-kotlin-concurrency-3/src/main/java/com/baeldung/schedulingrepeatingtask/UsingScheduledThreadPool.kt

@@ -7,5 +7,5 @@ fun main(){
     val scheduler = Executors.newSingleThreadScheduledExecutor()
     scheduler.scheduleAtFixedRate({
         println("Complex task completed!")
-    }, 0L, 1L, TimeUnit.SECONDS)
+    }, 0, 1, TimeUnit.SECONDS)
 }

core-kotlin-modules/core-kotlin-concurrency-3/src/main/java/com/baeldung/schedulingrepeatingtask/UsingTimer.kt

@@ -5,7 +5,7 @@ import kotlin.concurrent.schedule
 
 fun main(){
     val timer = Timer()
-    timer.schedule(0L, 1000L) {
+    timer.schedule(0, 1000) {
         println("Timer ticked!")
     }
 }

core-kotlin-modules/core-kotlin-concurrency-3/src/test/java/com/baeldung/schedulingrepeatingtask/SchedulingRepeatingTaskUnitTest.kt

@@ -5,6 +5,7 @@ import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.take
 import kotlinx.coroutines.flow.transform
+import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
 import kotlin.time.Duration.Companion.milliseconds
@@ -13,10 +14,14 @@ class SchedulingRepeatingTaskUnitTest {
 
     @Test
     fun `using repeat and delay`() = runBlocking {
+        var count = 0
         repeat(10) {
-            println("Timer ticked!")
-            delay(1000)
+            count++
+            println("Timer ticked! $count")
+            delay(500)
         }
+
+        assertEquals(10, count)
     }
 
     @Test
@@ -33,56 +38,23 @@ class SchedulingRepeatingTaskUnitTest {
 
     // Using flow & collect
     @Test
-    fun `using flow collect`() = runBlocking {
-        var count = 0
-        val job = launch {
-            flow {
-                while (true) {
-                    emit(Unit)
-                    delay(1000.milliseconds)
-                }
-            }.collect {
-                count++
-                println("Task executed")
-                if (count == 10) cancel() // cancel after 10 executions
-            }
-        }
-        job.join()
-    }
+    fun `using flow collect take`() = runBlocking {
 
-    @Test
-    fun `using flow and take`() = runBlocking {
-        flow {
+        val flow = flow {
             while (true) {
                 emit(Unit)
                 delay(1000.milliseconds)
             }
-        }.take(10).collect {
-            println("Task executed times")
         }
-    }
 
-    // using flowOf & collect
-    @Test
-    fun `using flowOf`() = runBlocking {
-        flowOf(1, 2, 3, 4, 5).collect {
-            println("Received value: $it")
-            delay(1000.milliseconds)
-        }
-    }
+        var count = 0
 
-    // using flowOf, transform and collect
-    @Test
-    fun `using flowOf with transform`() = runBlocking {
-        flowOf(1, 2, 3, 4, 5).transform { value ->
-            emit("Task executed $value times")
-        }.collect {
-            println(it)
-            delay(1000.milliseconds)
+        flow.take(10).collect{
+            count++
+            println(count)
         }
-    }
-
-    // Using flow, take & collect
 
+        assertEquals(10, count)
+    }
 
 }