Merge pull request #5 from hangga/parallel-slf4j

update

Author: hangga

core-kotlin-modules/core-kotlin-collections-6/src/test/kotlin/com/baeldung/parallelOperationsCollections/ParallelOperationCollectionsUnitTest.kt

@@ -10,17 +10,18 @@ import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.runBlocking
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
-import java.text.SimpleDateFormat
+import org.slf4j.LoggerFactory
 import java.time.Duration
 import java.time.Instant
-import java.util.*
 import java.util.concurrent.Callable
 import java.util.concurrent.Executors
 import java.util.stream.Collectors
 
 
 class ParallelOperationCollectionsUnitTest {
 
+    private val logger = LoggerFactory.getLogger("")
+
     data class Person(val name: String, val age: Int, var isAdult: Boolean? = null)
 
     private val people = listOf(
@@ -34,31 +35,28 @@ class ParallelOperationCollectionsUnitTest {
 
     private fun List<Person>.assertResultsTrue() {
         assertThat(this).containsExactly(
-            Person("Bob", 16, false),
-            Person("Alice", 30, true),
-            Person("Charlie", 40, true),
-            Person("Ahmad", 42, true)
-        )
-    }
-
-    private fun Person.setAdult(){
-        this.isAdult = this.age >= 18
-
-        println(
-            "%-25s %-45s %-40s".format(
-                SimpleDateFormat("yyyy-MM-dd:HH:mm:ss:SSS").format(Date.from(Instant.now())),
-                this.toString(),
-                Thread.currentThread().name
+                Person("Bob", 16, false),
+                Person("Alice", 30, true),
+                Person("Charlie", 40, true),
+                Person("Ahmad", 42, true)
             )
-        )
     }
 
     private fun String.printAsHeader() {
-        println("$this ${"-".repeat(100 - this.length)}\n${"%-25s %-45s %-40s".format("Time", "Operation", "Thread name")}")
+        logger.info("{} {}", "-".repeat(32 - Thread.currentThread().name.length), this)
+    }
+
+    private fun Person.setAdult() {
+        this.isAdult = this.age >= 18
+        val line = " ".repeat(32 - Thread.currentThread().name.length)
+        logger.info("{} {}", line, this)
     }
 
     private fun Instant.printTotalTime() {
-        println("Total time taken: ${Duration.between(this, Instant.now()).toMillis()} ms\n")
+        val totalTime = Duration.between(this, Instant.now()).toMillis()
+        logger.info(
+            "{} Total time taken: {} ms \n", "-".repeat(32 - Thread.currentThread().name.length), totalTime
+        )
     }
 
     @Test
@@ -67,11 +65,11 @@ class ParallelOperationCollectionsUnitTest {
         val startTime = Instant.now()
 
         val filteredPeople = people.map { person ->
-            async {
-                person.setAdult()
-                person
-            }
-        }.awaitAll().filter { it.age > 15 }.sortedBy { it.age }
+                async {
+                    person.setAdult()
+                    person
+                }
+            }.awaitAll().filter { it.age > 15 }.sortedBy { it.age }
 
         startTime.printTotalTime()
 
@@ -85,13 +83,15 @@ class ParallelOperationCollectionsUnitTest {
         val startTime = Instant.now()
 
         val filteredPeople = people.asFlow().flatMapMerge { person ->
-            flow {
-                emit(async {
-                    person.setAdult()
-                    person
-                }.await())
-            }
-        }.filter { it.age > 15 }.toList().sortedBy { it.age }
+                flow {
+                    emit(
+                        async {
+                            person.setAdult()
+                            person
+                        }.await()
+                    )
+                }
+            }.filter { it.age > 15 }.toList().sortedBy { it.age }
 
         startTime.printTotalTime()
 
@@ -103,12 +103,17 @@ class ParallelOperationCollectionsUnitTest {
         "Using RxJava".printAsHeader()
         val startTime = Instant.now()
 
-        val observable = Observable.fromIterable(people).flatMap({
-            Observable.just(it).subscribeOn(Schedulers.computation()).doOnNext { person ->
-                person.setAdult()
-            }
-        }, people.size) // Uses maxConcurrency for the number of elements
-            .filter { it.age > 15 }.toList().map { it.sortedBy { person -> person.age } }.blockingGet()
+        val observable = Observable.fromIterable(people).flatMap(
+                {
+                    Observable.just(it).subscribeOn(Schedulers.computation()).doOnNext { person ->
+                        person.setAdult()
+                    }
+                }, people.size // Uses maxConcurrency for the number of elements
+            )
+            .filter { it.age > 15 }
+            .toList()
+            .map { it.sortedBy { person -> person.age } }
+            .blockingGet()
 
         startTime.printTotalTime()
 
@@ -120,12 +125,16 @@ class ParallelOperationCollectionsUnitTest {
         "Using RxKotlin".printAsHeader()
         val startTime = Instant.now()
 
-        val observable = people.toObservable().flatMap({
-            Observable.just(it).subscribeOn(Schedulers.computation()).doOnNext { person ->
-                person.setAdult()
-            }
-        }, people.size) // Uses maxConcurrency for the number of elements
-            .filter { it.age > 15 }.toList().map { it.sortedBy { person -> person.age } }.blockingGet()
+        val observable = people.toObservable().flatMap(
+                {
+                    Observable.just(it).subscribeOn(Schedulers.computation()).doOnNext { person ->
+                        person.setAdult()
+                    }
+                }, people.size // Uses maxConcurrency for the number of elements
+            ).filter { it.age > 15 }
+            .toList()
+            .map { it.sortedBy { person -> person.age } }
+            .blockingGet()
 
         startTime.printTotalTime()
 
@@ -137,10 +146,12 @@ class ParallelOperationCollectionsUnitTest {
         "Using RxKotlin 1 thread".printAsHeader()
         val startTime = Instant.now()
 
-        val observable =
-            people.toObservable().subscribeOn(Schedulers.io()).flatMap { Observable.just(it) }.doOnNext { person ->
-                person.setAdult()
-            }.filter { it.age > 15 }.toList().map { it.sortedBy { person -> person.age } }.blockingGet()
+        val observable = people.toObservable()
+            .subscribeOn(Schedulers.io())
+            .flatMap { Observable.just(it) }
+            .doOnNext { person -> person.setAdult() }
+            .filter { it.age > 15 }.toList()
+            .map { it.sortedBy { person -> person.age } }.blockingGet()
 
         startTime.printTotalTime()
 
@@ -153,10 +164,11 @@ class ParallelOperationCollectionsUnitTest {
         val startTime = Instant.now()
 
         val filteredPeople = people.parallelStream().map { person ->
-            
-            person.setAdult()
-            person
-        }.filter { it.age > 15 }.sorted { p1, p2 -> p1.age.compareTo(p2.age) }.collect(Collectors.toList())
+                person.setAdult()
+                person
+            }.filter { it.age > 15 }
+            .sorted { p1, p2 -> p1.age.compareTo(p2.age) }
+            .collect(Collectors.toList())
 
         startTime.printTotalTime()
 
@@ -170,11 +182,11 @@ class ParallelOperationCollectionsUnitTest {
 
         val executor = Executors.newFixedThreadPool(people.size)
         val futures = people.map { person ->
-            executor.submit(Callable {
-                person.setAdult()
-                person
-            })
-        }.map { it.get() }.filter { it.age > 15 }.sortedBy { it.age }
+                executor.submit(Callable {
+                    person.setAdult()
+                    person
+                })
+            }.map { it.get() }.filter { it.age > 15 }.sortedBy { it.age }
 
         executor.shutdown()
 
@@ -183,3 +195,4 @@ class ParallelOperationCollectionsUnitTest {
         futures.assertResultsTrue()
     }
 }
+