[conditional-exception] update

Author: sk1418

core-kotlin-modules/core-kotlin-exceptions/src/test/kotlin/com/baeldung/conditionalThrowing/ConditionalThrowingUnitTest.kt

@@ -12,7 +12,7 @@ inline fun throwIf(throwCondition: Boolean, exProvider: () -> Exception) {
 }
 
 inline fun <T : Any?> T.mustHave(
-    otherwiseThrow: (T) -> Exception = { IllegalStateException("mustHave: check failed") },
+    otherwiseThrow: (T) -> Exception = { IllegalStateException("mustHave check failed: $it") },
     require: (T) -> Boolean
 ): T {
     if (!require(this)) throw otherwiseThrow(this)
@@ -29,7 +29,8 @@ class ConditionalThrowingUnitTest {
         val str = "a b c"
         assertThrows<IllegalArgumentException> {
             require(str.length > 10) { "The string is too short." }
-        }.also { ex -> assertEquals("The string is too short.", ex.message) }
+            null.toString()
+        }
 
         val upperStr = str.also {
             require(it.split(" ").size == 3) { "Format not supported" }
@@ -40,7 +41,7 @@ class ConditionalThrowingUnitTest {
         var nullableValue: String? = null
         assertThrows<IllegalArgumentException> {
             requireNotNull(nullableValue) { "Null is not allowed" }
-        }.also { ex -> assertEquals("Null is not allowed", ex.message) }
+        }
 
         nullableValue = "a b c"
         val uppercaseValue = requireNotNull(nullableValue).uppercase()
@@ -52,12 +53,12 @@ class ConditionalThrowingUnitTest {
         val str = "a b c"
         assertThrows<IllegalStateException> {
             check(str.length > 10) { "The string is too short." }
-        }.also { ex -> assertEquals("The string is too short.", ex.message) }
+        }
 
         var nullableValue: String? = null
         assertThrows<IllegalStateException> {
             checkNotNull(nullableValue) { "Null is not allowed" }
-        }.also { ex -> assertEquals("Null is not allowed", ex.message) }
+        }
 
         nullableValue = "a b c"
         val uppercaseValue = checkNotNull(nullableValue).uppercase()
@@ -70,21 +71,21 @@ class ConditionalThrowingUnitTest {
         val str = "a b c"
         assertThrows<MyException> {
             str.takeIf { it.length > 10 } ?: throw MyException("The string is too short.")
-        }.also { ex -> assertEquals("The string is too short.", ex.message) }
+        }
 
         val nullIsValid: String? = null
         // we don't expect the exception
         assertThrows<MyException> {
-            nullIsValid.takeIf { it == null || it.length > 10 } ?: throw MyException("The string is too short.")
-        }.also { ex -> assertEquals("The string is too short.", ex.message) }
+            nullIsValid.takeIf { true } ?: throw MyException("The string is too short.")
+        }
     }
 
     @Test
     fun `when using throwIf() then get expected results`() {
         val str = "a b c"
         assertThrows<MyException> {
             throwIf(str.length <= 10) { MyException("The string is too short.") }
-        }.also { ex -> assertEquals("The string is too short.", ex.message) }
+        }
 
         val uppercaseValue = str.also {
             throwIf(it.split(" ").size != 3) { MyException("Format not supported") }
@@ -97,7 +98,7 @@ class ConditionalThrowingUnitTest {
     fun `when using mustHave() then get expected results`() {
         val kai = Player(1, "Kai", -5)
         assertThrows<IllegalStateException> { kai.mustHave { it.score >= 0 } }
-            .also { ex -> assertEquals("mustHave: check failed", ex.message) }
+            .also { ex -> assertEquals("mustHave check failed: Player(id=1, name=Kai, score=-5)", ex.message) }
 
         assertThrows<InvalidPlayerException> {
             kai.mustHave(