Merge branch 'KTLN-609/ktor-thymeleaf' of github.com:fabiotadashi/kotlin-tutorials into KTLN-609/ktor-thymeleaf

Author: fabiotadashi

core-kotlin-modules/core-kotlin-9/src/test/kotlin/com/baeldung/passbyvalue/PassByValueOrReferenceUnitTest.kt

@@ -0,0 +1,37 @@
+package com.baeldung.passbyvalue
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class PassByValueOrReferenceUnitTest {
+
+    data class SomeObj(var x: Int = 0)
+
+    private fun modifyObject(someObj: SomeObj) {
+        someObj.x = 3
+    }
+
+    private fun modifyValue(value: Int): Int {
+        return value + 10
+    }
+
+    @Test
+    fun `Test using pass-by-reference`() {
+        val obj = SomeObj()
+
+        assertEquals( 0, obj.x) // before modify
+
+        modifyObject(obj)
+
+        assertEquals(3, obj.x) // after modify
+    }
+
+    @Test
+    fun `Test using pass-by-value`(){
+        val num = 5
+        val modifiedNum = modifyValue(num)
+
+        assertEquals(5, num)
+        assertEquals(15, modifiedNum)
+    }
+}

core-kotlin-modules/core-kotlin-arrays-2/src/test/kotlin/com/baeldung/iterateArrayReversely/IterateArrayReverselyUnitTest.kt

@@ -0,0 +1,38 @@
+package com.baeldung.iterateArrayReversely
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+class IterateArrayReverselyUnitTest {
+    private val array = arrayOf("a", "b", "c", "d", "e", "f")
+    private val reversedList = listOf("f", "e", "d", "c", "b", "a")
+
+    @Test
+    fun `when using reversed() on index Range, then get expected result`() {
+        val resultList = mutableListOf<String>()
+
+        for (i in array.indices.reversed()) {
+            resultList += array[i]
+        }
+
+        assertEquals(reversedList, resultList)
+    }
+
+    @Test
+    fun `when using downTo on indexes, then get expected result`() {
+        val resultList = mutableListOf<String>()
+        for (i in (array.lastIndex downTo 0)) {
+            resultList += array[i]
+        }
+        assertEquals(reversedList, resultList)
+    }
+
+    @Test
+    fun `when using reversed() on the array, then get expected result`() {
+        val resultList = mutableListOf<String>()
+        for (element in array.reversed()) {
+            resultList += element
+        }
+        assertEquals(reversedList, resultList)
+    }
+}

core-kotlin-modules/core-kotlin-collections-list-2/src/test/kotlin/typeErasedListToArray/TypeErasedListToArrayUnitTest.kt

@@ -0,0 +1,47 @@
+package typeErasedListToArray
+
+import org.junit.jupiter.api.Assertions.assertArrayEquals
+import org.junit.jupiter.api.Test
+
+class typeErasedListToArrayUnitTest {
+
+    @Test
+    fun `convert type-erased list to array using toTypedArray`() {
+        val intList: List<Any> = listOf(1, 2, 3, 4, 5)
+        val stringList: List<Any> = listOf("one", "two", "three", "four", "five")
+
+        val array1 = intList.toTypedArray()
+        val array2 = stringList.toTypedArray()
+
+        assertArrayEquals(arrayOf(1, 2, 3, 4, 5), array1)
+        assertArrayEquals(arrayOf("one", "two", "three", "four", "five"), array2)
+    }
+
+    @Test
+    fun `convert type-erased list to array using toTypedArray with reified and inline`() {
+        val intList: List<Any> = listOf(1, 2, 3, 4, 5)
+        val stringList: List<Any> = listOf("one", "two", "three", "four", "five")
+
+        val array1 = mapToArray<Int>(intList)
+        val array2 = mapToArray<String>(stringList)
+
+        assertArrayEquals(arrayOf(1, 2, 3, 4, 5), array1)
+        assertArrayEquals(arrayOf("one", "two", "three", "four", "five"), array2)
+    }
+
+    @Test
+    fun `convert type-erased list to array using array constructor`() {
+        val intList: List<Any> = listOf(1, 2, 3, 4, 5)
+        val stringList: List<Any> = listOf("one", "two", "three", "four", "five")
+
+        var array1 = Array(intList.size) { i -> intList[i] as Int}
+        val array2 = Array(stringList.size) { i -> stringList[i] as String}
+
+        assertArrayEquals(arrayOf(1, 2, 3, 4, 5), array1)
+        assertArrayEquals(arrayOf("one", "two", "three", "four", "five"), array2)
+    }
+
+    inline fun <reified T> mapToArray(list: List<*>): Array<T> {
+        return list.mapNotNull{ it as? T }.toTypedArray()
+    }
+}

core-kotlin-modules/core-kotlin-lang-4/src/test/kotlin/com/baeldung/pair/workingWithTriple/WorkingWithTripleUnitTest.kt

@@ -0,0 +1,98 @@
+package com.baeldung.pair.workingWithTriple
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+data class Player(
+    val name: String,
+    var score: Int
+)
+
+
+
+typealias Match = Triple<Player, Player, String>
+
+fun Match.firstWin() = apply {
+    first.score++
+    second.score--
+}
+
+fun Match.secondWin() = apply {
+    first.score--
+    second.score++
+}
+
+class WorkingWithTripleUnitTest {
+
+    @Test
+    fun `when calling toString, then get the expected result`() {
+        val t = Triple("A", "B", "C")
+        assertEquals("(A, B, C)", t.toString())
+        assertEquals("(A, B, C)", "$t")
+    }
+
+    @Test
+    fun `when assignment with deconstruction, then get the expected result`() {
+        val (a, b, c) = Triple(42, "Kotlin", Long.MAX_VALUE)
+        assertTrue { a is Int }
+        assertEquals(42, a)
+
+        assertTrue { b is String }
+        assertEquals("Kotlin", b)
+
+        assertTrue { c is Long }
+        assertEquals(Long.MAX_VALUE, c)
+    }
+
+    @Test
+    fun `when calling triple-toList(), then get the expected result`() {
+        val t = Triple("Java", "Kotlin", "Python")
+        assertEquals(listOf("Java", "Kotlin", "Python"), t.toList())
+    }
+
+    fun <T> Triple<T, T, T>.reverse() = Triple(third, second, first)
+
+    @Test
+    fun `when reversing a triple, then get the expected result`() {
+        val t = Triple("x", "y", "z")
+        assertEquals(Triple("z", "y", "x"), t.reverse())
+    }
+
+    @Test
+    fun `when using triple store matches, then get the expected result`() {
+        val kent = Player("Kent", 42)
+        val eric = Player("Eric", 42)
+        val tom = Player("Tom", 20)
+        val john = Player("John", 32)
+
+        val matchesTomorrow = listOf(
+            Triple(kent, tom, "9:00"),
+            Triple(eric, john, "10:00"),
+            Triple(kent, eric, "17:00"),
+            Triple(tom, john, "18:00"),
+        )
+
+        val matchAt10 = matchesTomorrow.first { it.third == "10:00" }
+        assertEquals(eric, matchAt10.first)
+        assertEquals(john, matchAt10.second)
+
+        //using type alias
+        val matchesTomorrow2 = listOf(
+            Match(kent, tom, "9:00"),
+            Match(eric, john, "10:00"),
+            Match(kent, eric, "17:00"),
+            Match(tom, john, "18:00"),
+        )
+
+        val matchAt17 = matchesTomorrow2.first { it.third == "17:00" }
+        assertEquals(kent, matchAt17.first)
+        assertEquals(eric, matchAt17.second)
+
+        matchAt17.secondWin()
+
+        assertEquals(41, matchAt17.first.score)
+        assertEquals(43, matchAt17.second.score)
+
+    }
+}

kotlin-lambda/src/test/kotlin/com/baeldung/functionAsDefaultArgument/FunctionAsDefaultArgumentUnitTest.kt

@@ -0,0 +1,75 @@
+package com.baeldung.functionAsDefaultArgument
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+fun greeting(name: String = "Baeldung"): String {
+    return "Hi $name"
+}
+
+fun greeting1(name: String = "Baeldung", buildMessage: (String) -> String): String {
+    return "Hi $name, ${buildMessage(name)}"
+}
+
+fun greeting2(name: String = "Baeldung", buildMessage: (String) -> String = { input: String ->
+    "your name is ${if (input.length > 3) "long" else "short"}."
+}): String {
+    return "Hi $name, ${buildMessage(name)}"
+}
+
+fun greeting3(name: String = "Baeldung", buildMessage: (String) -> String = { _ -> "how do you do?" }): String {
+    return "Hi $name, ${buildMessage(name)}"
+}
+
+class FunctionAsDefaultArgumentUnitTest {
+
+    val msgByCharCount: (String) -> String = { input: String ->
+        "your name has an ${if (input.length % 2 == 1) "odd" else "even"} number of letters."
+    }
+
+    @Test
+    fun `when calling greeting with or without passing parameter, then get expected result`() {
+        assertEquals("Hi Baeldung", greeting())
+        assertEquals("Hi Kai", greeting("Kai"))
+    }
+
+    @Test
+    fun `when calling greeting1, then get expected result`() {
+        val msgWithDefaultName = greeting1(buildMessage = msgByCharCount)
+        assertEquals("Hi Baeldung, your name has an even number of letters.", msgWithDefaultName)
+
+        val kaiMsg = greeting1(name = "Kai", buildMessage = msgByCharCount)
+        assertEquals("Hi Kai, your name has an odd number of letters.", kaiMsg)
+    }
+
+    @Test
+    fun `when calling greeting2, then get expected result`() {
+        val result1 = greeting2()
+        assertEquals("Hi Baeldung, your name is long.", result1)
+
+        val result2 = greeting2("Kai")
+        assertEquals("Hi Kai, your name is short.", result2)
+
+        val result3 = greeting2(buildMessage = msgByCharCount)
+        assertEquals("Hi Baeldung, your name has an even number of letters.", result3)
+
+        val result4 = greeting2(name = "Kai", buildMessage = msgByCharCount)
+        assertEquals("Hi Kai, your name has an odd number of letters.", result4)
+    }
+
+    @Test
+    fun `when calling greeting3, then get expected result`() {
+        val result1 = greeting3()
+        assertEquals("Hi Baeldung, how do you do?", result1)
+
+        val result2 = greeting3("Kai")
+        assertEquals("Hi Kai, how do you do?", result2)
+
+        val result3 = greeting3(buildMessage = msgByCharCount)
+        assertEquals("Hi Baeldung, your name has an even number of letters.", result3)
+
+        val result4 = greeting3(name = "Kai", buildMessage = msgByCharCount)
+        assertEquals("Hi Kai, your name has an odd number of letters.", result4)
+    }
+
+}