Merge branch 'master' into JAVA-42094

# Conflicts:
#	core-kotlin-modules/core-kotlin-flows/pom.xml

Author: Bipinkumar27

core-kotlin-modules/core-kotlin-advanced-4/src/test/kotlin/com/baeldung/resolvePrimaryConstructorCallExpectedIssue/resolvePrimaryConstructorCallExpectedIssueUnitTest.kt

@@ -0,0 +1,48 @@
+package com.baeldung.resolvePrimaryConstructorCallExpectedIssue
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+class resolvePrimaryConstructorCallExpectedIssueUnitTest {
+
+    @Test
+    fun `correctly resolve compile error by properly defining constructors`() {
+        val student = Student("Martial", 15)
+
+        assertEquals("Martial", student.name)
+        assertEquals(15, student.age)
+    }
+
+    @Test
+    fun `correctly resolve compile error by properly using the secondary constructor`() {
+        val dog = Dog("Max")
+        assertEquals("Max", dog.species)
+    }
+
+    @Test
+    fun `correctly resolve compile error by properly using default parameters`() {
+        val car1 = Car("Toyota", "Corolla")
+
+        assertEquals("Toyota", car1.make)
+        assertEquals("Corolla", car1.model)
+
+    }
+}
+
+class Student(var name: String) {
+    var age: Int = 14
+
+    constructor(name: String, age: Int) : this(name) {
+        this.age = age
+    }
+
+    fun printMsg() {
+        println("Name is $name. Age is $age.")
+    }
+}
+
+open class Animal(val species: String)
+
+class Dog(species: String) : Animal(species)
+
+class Car(val make: String, val model: String = "Unknown")

core-kotlin-modules/core-kotlin-flows/pom.xml

@@ -21,13 +21,30 @@
         <dependency>
             <groupId>org.jetbrains.kotlinx</groupId>
             <artifactId>kotlinx-coroutines-reactor</artifactId>
-            <version>1.9.0</version>
+            <version>${kotlinx.coroutines.version}</version>
+
         </dependency>
         <dependency>
             <groupId>io.projectreactor</groupId>
             <artifactId>reactor-core</artifactId>
-            <version>3.6.10</version>
+            <version>${reactor.version}</version>
+        </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>
+        <junit.version>4.13.2</junit.version>
+        <kotlinx.coroutines.version>1.7.3</kotlinx.coroutines.version>
+        <reactor.version>3.4.11</reactor.version>
+    </properties>
 </project>

core-kotlin-modules/core-kotlin-flows/src/test/kotlin/com/baeldung/flowTest/FlowTestUnitTest.kt

@@ -0,0 +1,144 @@
+package com.baeldung.flowTest
+
+import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.onFailure
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.test.advanceTimeBy
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import java.util.concurrent.CancellationException
+
+class FlowTestUnitTest {
+
+    @Test
+    fun `simpleFlow should emit 1 2 3`() = runTest {
+        val flow = simpleFlow().toList()
+
+        assertEquals(listOf(1, 2, 3), flow)
+    }
+
+    @Test
+    fun `transformedFlow should multiply values by 2`() = runTest {
+        val result = transformedFlow().toList()
+        assertEquals(listOf(2, 4, 6), result)
+    }
+
+    @Test
+    fun `errorFlow should emit values and recover from exception`() = runTest {
+        val emittedValues = errorFlow().toList()
+
+        assertEquals(listOf(1, 2, -1), emittedValues)
+    }
+
+    @Test
+    fun `implicitCancellationFlow stops on cancellation`() = runTest {
+        val emittedValues = mutableListOf<Int>()
+        val job = launch {
+            implicitCancellationFlow().collect { emittedValues.add(it) }
+        }
+
+        advanceTimeBy(600)
+        job.cancelAndJoin()
+
+        assertEquals(listOf(1,2), emittedValues)
+    }
+
+    @Test
+    fun `cancellableFlow stops emitting after external cancellation`() = runTest {
+        val emittedValues = mutableListOf<Int>()
+        val job = launch {
+            cancellableFlow().collect { emittedValues.add(it) }
+        }
+
+        advanceTimeBy(2000)
+        job.cancelAndJoin()
+
+        assertEquals(listOf(0, 1), emittedValues)
+    }
+
+    @Test
+    fun `uncancellableFlow ensures cleanup occurs`() = runTest {
+        val emittedValues = mutableListOf<Int>()
+        val job = launch {
+            uncancellableFlow().collect { emittedValues.add(it) }
+        }
+
+        advanceTimeBy(400)
+        job.cancelAndJoin()
+
+        assertEquals(listOf(1), emittedValues)
+    }
+
+    @Test
+    fun `delayedFlow should handle delayed emissions`() = runTest {
+        val result = delayedFlow().toList()
+        assertEquals(listOf(1, 2), result)
+    }
+}
+
+fun simpleFlow(): Flow<Int> = flow {
+    emit(1)
+    emit(2)
+    emit(3)
+}
+
+fun transformedFlow(): Flow<Int> = flow {
+    emit(1)
+    emit(2)
+    emit(3)
+}.map { it * 2 }
+
+fun errorFlow(): Flow<Int> = flow {
+    emit(1)
+    emit(2)
+    throw Exception("Test Exception")
+}.catch { e ->
+    emit(-1)
+}
+
+fun cancellableFlow(): Flow<Int> = flow {
+    try {
+        repeat(5) {
+            emit(it)
+            delay(1000)
+        }
+    } finally {
+        println("Cleanup: Emitting -1")
+        emit(-1)
+    }
+}.onEach { value ->
+    if (value == 2) throw CancellationException("Flow was canceled at value 2")
+}.onCompletion { cause ->
+    if (cause is CancellationException) {
+        println("Flow canceled: Releasing resources")
+    }
+}
+
+fun delayedFlow(): Flow<Int> = flow {
+    delay(500)
+    emit(1)
+    delay(500)
+    emit(2)
+}
+
+fun implicitCancellationFlow(): Flow<Int> = flow {
+    emit(1)
+    delay(500)
+    emit(2)
+    delay(500)
+    emit(3)
+}
+
+fun uncancellableFlow(): Flow<Int> = flow {
+    try {
+        emit(1)
+        delay(500)
+        emit(2)
+    } finally {
+        withContext(NonCancellable) {
+            println("Releasing resources")
+        }
+    }
+}

core-kotlin-modules/core-kotlin-flows/src/test/kotlin/com/baeldung/takeWhileTransformWhile/TakeWhileVsTransformWhileUnitTest.kt

@@ -0,0 +1,49 @@
+package com.baeldung.concatenateTwoFlows
+
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.runBlocking
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
+
+class TakeWhileVsTransformWhileUnitTest {
+
+    @Test
+    fun `takeWhile less than 3 returns 1 and 2`() {
+        runBlocking {
+            val numbersFlow = flowOf(1, 2, 3, 4, 5)
+
+            val taken = numbersFlow.takeWhile { it < 3 }.toList()
+
+            Assertions.assertEquals(listOf(1, 2), taken)
+        }
+    }
+
+    @Test
+    fun `transformWhile less than 3 can return 1, 2 and 3`() {
+        runBlocking {
+            val numbersFlow = flowOf(1, 2, 3, 4, 5)
+
+            val transformed = numbersFlow.transformWhile {
+                emit(it)
+                it < 3
+            }.toList()
+
+            Assertions.assertEquals(listOf(1, 2, 3), transformed)
+        }
+    }
+
+    @Test
+    fun `transformWhile can transform elements`() {
+        runBlocking {
+            val numbersFlow = flowOf(1, 2, 3, 4, 5)
+
+            val transformed = numbersFlow.transformWhile {
+                emit("" + it)
+                emit("" + it * 2)
+                it < 3
+            }.toList()
+
+            Assertions.assertEquals(listOf("1", "2", "2", "4", "3", "6"), transformed)
+        }
+    }
+}

kotlin-gradle-libraries/build.gradle.kts

@@ -0,0 +1,25 @@
+plugins {
+    kotlin("jvm") version "2.0.20"
+}
+
+group = "com.baeldung"
+version = "1.0-SNAPSHOT"
+
+repositories {
+    mavenCentral()
+    maven("https://packages.jetbrains.team/maven/p/kds/kotlin-ds-maven")
+}
+
+dependencies {
+    implementation("org.jetbrains.kotlinx:kandy-lets-plot:0.7.1")
+    implementation("org.jetbrains.kotlinx:kotlin-statistics-jvm:0.3.1")
+    testImplementation("org.assertj:assertj-core:3.6.1")
+    testImplementation(kotlin("test"))
+}
+
+tasks.test {
+    useJUnitPlatform()
+}
+kotlin {
+    jvmToolchain(21)
+}

kotlin-gradle-libraries/gradle/wrapper/gradle-wrapper.jar

@@ -0,0 +1,6 @@
+#Sat Nov 23 18:46:55 CET 2024
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists