[KTLN-763] Add samples (#1092)

* [KTLN-177] Add samples

* [KTLN-177] Extract strings to properties

Author: LeoColman

core-kotlin-modules/core-kotlin-concurrency-4/pom.xml

@@ -11,4 +11,29 @@
 
     <artifactId>core-kotlin-concurrency-4</artifactId>
 
-</project>
+    <dependencies>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains.kotlinx</groupId>
+            <artifactId>kotlinx-coroutines-core</artifactId>
+            <version>${kotlinx.coroutines.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains.kotlinx</groupId>
+            <artifactId>kotlinx-coroutines-test</artifactId>
+            <version>${kotlinx.coroutines.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <project.version>1.0.0-SNAPSHOT</project.version>
+        <assertj.version>3.24.2</assertj.version>
+        <kotlinx.coroutines.version>1.7.3</kotlinx.coroutines.version>
+    </properties>
+</project>

core-kotlin-modules/core-kotlin-concurrency-4/src/test/kotlin/com/baeldung/schedulertimer/SchedulerTimerUnitTest.kt

@@ -0,0 +1,75 @@
+package com.baeldung.schedulertimer
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.TimeoutCancellationException
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.within
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+
+fun CoroutineScope.startTimer(delay: Long = 1000L, task: suspend () -> Unit): Job {
+    return launch {
+        delay(delay)
+        task()
+    }
+}
+
+fun CoroutineScope.startInfiniteScheduler(interval: Long = 1000L, task: suspend () -> Unit): Job {
+    return launch {
+        while (isActive) {
+            task()
+            delay(interval)
+        }
+    }
+}
+
+suspend fun runWithTimeout(timeout: Long, task: suspend () -> Unit) {
+    withTimeout(timeout) {
+        task()
+    }
+}
+
+
+class SchedulerTimerUnitTest {
+
+    @Test
+    fun `timer executes task after delay`() = runBlocking {
+        var taskExecuted = false
+        val task: suspend () -> Unit = { taskExecuted = true }
+
+        startTimer(delay = 1000L, task = task)
+        delay(1500L)
+
+        assertTrue(taskExecuted)
+    }
+
+    @Test
+    fun `infinite scheduler stops when scope is canceled`(): Unit = runBlocking {
+        var taskExecutionCount = 0
+        val task: suspend () -> Unit = { taskExecutionCount++ }
+
+        val schedulerJob = startInfiniteScheduler(interval = 500L, task = task)
+        delay(1500L)
+
+        schedulerJob.cancel()
+        schedulerJob.join()
+
+        assertThat(taskExecutionCount).isCloseTo(3, within(1))
+    }
+
+    @Test
+    fun `runWithTimeout throws TimeoutCancellationException if task exceeds timeout`(): Unit = runBlocking {
+        val task: suspend () -> Unit = { delay(2000L) }
+        assertThrows<TimeoutCancellationException> {
+            runWithTimeout(timeout = 1000L, task = task)
+        }
+    }
+
+}