Merge branch 'Baeldung:master' into master

Author: diegotorrespy

README.md

@@ -9,7 +9,7 @@ Building the project
 
 To build the entire repository with only Unit Tests enabled run:
 
-`mvn clean install`
+`mvn clean install -Pdefault`
 
 or if we want to build the entire repository with Integration Tests enabled, we can do:
 

core-kotlin-companion/pom.xml

@@ -1,8 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
->
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <artifactId>core-kotlin-companion</artifactId>
     <name>core-kotlin-companion</name>
@@ -14,9 +13,4 @@
         <version>1.0.0-SNAPSHOT</version>
     </parent>
 
-
-
-    <properties>
-    </properties>
-
 </project>

core-kotlin-modules/core-kotlin-10/README.md

@@ -1,4 +1,13 @@
-## Relevant Articles
+### Relevant Articles
 - [Determine Operating System in Kotlin](https://www.baeldung.com/kotlin/operating-system-identify)
 - [Kotlin when vs. Java switch Statement](https://www.baeldung.com/kotlin/when-vs-java-switch)
 - [Kotlin AES Encryption and Decryption](https://www.baeldung.com/kotlin/advanced-encryption-standard)
+- [Cloning an Object in Kotlin](https://www.baeldung.com/kotlin/clone-object)
+- [Assignment in While Expression in Kotlin](https://www.baeldung.com/kotlin/while-variable-assignment)
+- [Breadth-First Search Algorithm in Kotlin](https://www.baeldung.com/kotlin/bfs-graphs)
+- [Calling Private Methods of a Class From Outside the Class](https://www.baeldung.com/kotlin/private-methods-outside-class)
+- [Pass a Function as Parameter to Another in Kotlin](https://www.baeldung.com/kotlin/function-parameter-high-order)
+- [Accessing Methods Outside Companion Object in Kotlin](https://www.baeldung.com/kotlin/companion-object-external-methods)
+- [Accessing Private Java Fields via Kotlin Extension Functions](https://www.baeldung.com/kotlin/extension-functions-private-fields)
+- [Variable Shadowing in Kotlin](https://www.baeldung.com/kotlin/variable-shadowing)
+- More articles: [[<-- prev]](../core-kotlin-9)

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

@@ -3,14 +3,15 @@
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
          http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>core-kotlin-10</artifactId>
+    <name>core-kotlin-10</name>
+    <packaging>jar</packaging>
 
     <parent>
         <groupId>com.baeldung</groupId>
         <artifactId>core-kotlin-modules</artifactId>
         <version>1.0.0-SNAPSHOT</version>
     </parent>
 
-    <modelVersion>4.0.0</modelVersion>
-    <artifactId>core-kotlin-10</artifactId>
-
 </project>

core-kotlin-modules/core-kotlin-10/src/main/java/com/baeldung/StringWrapper.java

@@ -0,0 +1,21 @@
+package com.baeldung;
+
+public class StringWrapper {
+  private final String source;
+
+  public StringWrapper(String source) {
+    this.source = source;
+  }
+
+  public boolean containsIgnoreCase(String other) {
+    if (source == null) {
+      return false;
+    }
+
+    return source.toLowerCase().contains(other.toLowerCase());
+  }
+
+  public String getSource() {
+    return source;
+  }
+}

core-kotlin-modules/core-kotlin-10/src/main/kotlin/com/baeldung/access_private_members_from_extension_func/Main.kt

@@ -0,0 +1,18 @@
+package com.baeldung.access_private_members_from_extension_func
+
+class Main {
+  fun String?.containsIgnoreCase(target: String) : Boolean {
+    if (this == null) {
+      return false
+    }
+
+    val loadedClass = String::class
+    val valueField = loadedClass.java.getDeclaredField("value")
+    valueField?.isAccessible = true
+    val actualValue = valueField?.get(this) as? ByteArray
+
+    println(actualValue?.contentToString())
+
+    return this.lowercase().contains(target.lowercase())
+  }
+}

core-kotlin-modules/core-kotlin-10/src/main/kotlin/com/baeldung/bfs/Bfs.kt

@@ -0,0 +1,15 @@
+package com.baeldung.bfs
+
+fun bfs(graph: Map<Int, List<Int>>, start: Int): Set<Int> {
+    val visited = mutableSetOf<Int>()
+    val queue = ArrayDeque<Int>()
+    queue.add(start)
+    while (queue.isNotEmpty()) {
+        val vertex = queue.removeFirst()
+        if (vertex !in visited) {
+            visited.add(vertex)
+            graph[vertex]?.let { neighbors -> queue.addAll(neighbors.filterNot { it in visited }) }
+        }
+    }
+    return visited
+}

core-kotlin-modules/core-kotlin-10/src/test/kotlin/com/baeldung/bfs/BfsUnitTest.kt

@@ -0,0 +1,35 @@
+package com.baeldung.bfs
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class BfsUnitTest {
+    @Test
+    fun `test BFS traversal order`() {
+        val graph = mapOf(
+            1 to listOf(2, 3, 4),
+            2 to listOf(5, 6),
+            3 to listOf(),
+            4 to listOf(7, 8),
+            5 to listOf(),
+            6 to listOf(),
+            7 to listOf(),
+            8 to listOf()
+        )
+
+        val traversalOrder = bfs(graph, 1)
+
+
+        // Level 1
+        val levelOne = listOf(traversalOrder.first())
+        assertThat(levelOne).containsExactly(1)
+
+        // Level 2
+        val levelTwo = traversalOrder.drop(1).take(3)
+        assertThat(levelTwo).containsExactlyInAnyOrder(2, 3, 4)
+
+        // Level 3
+        val levelThree = traversalOrder.drop(4)
+        assertThat(levelThree).containsExactlyInAnyOrder(5, 6, 7, 8)
+    }
+}

core-kotlin-modules/core-kotlin-10/src/test/kotlin/com/baeldung/functionAsParameter/FunctionAsParameterUnitTest.kt

@@ -0,0 +1,90 @@
+package com.baeldung.functionAsParameter
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+fun joinByOperation(theList: List<String>, operation: (List<String>) -> String): String {
+    return operation(theList)
+}
+
+class MessageParser {
+    fun joinWithoutPlaceholder(segments: List<String>): String {
+        return segments.joinToString(separator = " ").replace(" [SPACE] ", " ")
+    }
+
+    companion object {
+        fun simplyJoin(segments: List<String>): String {
+            return segments.joinToString(separator = " ")
+        }
+    }
+}
+
+object ParserInObject {
+    fun joinWithoutComma(segments: List<String>): String {
+        return segments.joinToString(separator = " ") { it.replace(",", "") }
+    }
+}
+
+fun decrypt(segments: List<String>): String {
+    return segments.reversed().joinToString(separator = " ") { it.reversed() }
+}
+
+class FunctionAsParameterUnitTest {
+
+    @Test
+    fun `when passing lambda as parameters then get expected result`() {
+        val input = listOf("a b c", "d e f", "x y z")
+        val result1 = joinByOperation(input) { theList ->
+            theList.joinToString(separator = " ") { str -> str.reversed() }.replace(" ", ", ")
+        }
+        assertEquals("c, b, a, f, e, d, z, y, x", result1)
+
+        val result2 = joinByOperation(input) { theList ->
+            theList.reversed().joinToString(separator = " ") { str -> str }.uppercase()
+        }
+        assertEquals("X Y Z D E F A B C", result2)
+
+    }
+
+    @Test
+    fun `when passing instance function ref as parameters then get expected result`() {
+        val messageParser = MessageParser()
+        val input = listOf("a [SPACE] b [SPACE] c", "d [SPACE] e [SPACE] f", "x [SPACE] y [SPACE] z")
+        val result = joinByOperation(input, messageParser::joinWithoutPlaceholder)
+        assertEquals("a b c d e f x y z", result)
+    }
+
+    @Test
+    fun `when passing companion object function ref as parameters then get expected result`() {
+        val input = listOf("a b c", "d e f", "x y z")
+        val result = joinByOperation(input, MessageParser::simplyJoin)
+        assertEquals("a b c d e f x y z", result)
+    }
+
+    @Test
+    fun `when passing object function ref as parameters then get expected result`() {
+        val input = listOf("a, b, c", "d, e, f", "x, y, z")
+        val result = joinByOperation(input, ParserInObject::joinWithoutComma)
+        assertEquals("a b c d e f x y z", result)
+    }
+
+    @Test
+    fun `when passing top-level function ref as parameters then get expected result`() {
+        val input = listOf("z y x", "f e d", "c b a")
+        val result = joinByOperation(input, ::decrypt)
+        assertEquals("a b c d e f x y z", result)
+    }
+
+    @Test
+    fun `when passing variable with function type as parameter then get expected result`() {
+        val input = listOf("a, b, c", "d, e, f", "x, y, z")
+
+        val funRef = ParserInObject::joinWithoutComma
+        val resultFunRef = joinByOperation(input, funRef)
+        assertEquals("a b c d e f x y z", resultFunRef)
+
+        val funLambda = { theList: List<String> -> theList.reversed().joinToString(separator = ", ") { str -> str }.uppercase() }
+        val resultFunLambda = joinByOperation(input, funLambda)
+        assertEquals("X, Y, Z, D, E, F, A, B, C", resultFunLambda)
+    }
+}