How to use verifyThrowsAssertionWrapping method of com.sksamuel.kotest.throwablehandling.StrictThrowableHandlingTest class

...78      "Should throw an assertion error wrapping the thrown exception" - {79        "When the exact class is thrown" {80          val thrownException = FooRuntimeException()81          onShouldNotThrowExactlyMatcher<FooRuntimeException> { shouldNotThrowExactlyMatcher ->82            verifyThrowsAssertionWrapping(thrownException) {83              shouldNotThrowExactlyMatcher { throw thrownException }84            }85          }86        }87      }88      "Should throw the thrown exception" - {89        "When it's a subclass of the expected type" {90          val thrownException = SubException()91          onShouldNotThrowExactlyMatcher<ParentException> { shouldNotThrowExactlyMatcher ->92            verifyThrowsExactly(thrownException) {93              shouldNotThrowExactlyMatcher { throw thrownException }94            }95          }96        }97        "When it's a super class of the expected type" {98          val thrownException = ParentException()99          onShouldNotThrowExactlyMatcher<SubException> { shouldNotThrowExactlyMatcher ->100            verifyThrowsExactly(thrownException) {101              shouldNotThrowExactlyMatcher { throw thrownException }102            }103          }104        }105        "When it's unrelated to the expected type" {106          val thrownException = FooRuntimeException()107          onShouldNotThrowExactlyMatcher<ParentException> { shouldNotThrowExactlyMatcher ->108            verifyThrowsExactly(thrownException) {109              shouldNotThrowExactlyMatcher { throw thrownException }110            }111          }112        }113      }114      "Should not throw anything" - {115        "When nothing is thrown" {116          onShouldNotThrowExactlyMatcher<FooRuntimeException> { shouldNotThrowExactlyMatcher ->117            verifyNoErrorIsThrown {118              shouldNotThrowExactlyMatcher { /* Success */ }119            }120          }121        }122      }123    }124  }125  private inline fun <reified T : Throwable> onShouldThrowExactlyMatcher(func: (ShouldThrowExactlyMatcher<T>) -> Unit) {126    func(::shouldThrowExactlyUnit)127    func { shouldThrowExactly(it) }128  }129  private fun verifyNoExceptionThrownError(expectedClass: KClass<*>, block: () -> Unit) {130    val throwable = catchThrowable(block)131    throwable.shouldBeInstanceOf<AssertionError>()132    throwable.message shouldBe "Expected exception ${expectedClass.qualifiedName} but no exception was thrown."133  }134  private fun verifyThrowsAssertionErrorInstance(assertionErrorInstance: AssertionError, block: () -> Unit) {135    val throwable = catchThrowable(block)136    (throwable === assertionErrorInstance).shouldBeTrue()137  }138  private fun verifyThrowsWrongExceptionClass(thrownInstance: Throwable, expectedClass: KClass<*>, incorrectClass: KClass<*>, block: () -> Unit) {139    val throwable = catchThrowable(block)140    throwable.shouldBeInstanceOf<AssertionError>()141    throwable.message shouldBe "Expected exception ${expectedClass.qualifiedName} but a ${incorrectClass.simpleName} was thrown instead."142    (throwable.cause === thrownInstance).shouldBeTrue()143  }144  private fun verifyReturnsExactly(thrownException: Throwable, block: () -> Any?) {145    val actualReturn = block()146    (thrownException === actualReturn).shouldBeTrue()147  }148  private inline fun <reified T : Throwable> onShouldNotThrowExactlyMatcher(func: (ShouldNotThrowExactlyMatcher) -> Unit) {149    func { shouldNotThrowExactly<T>(it) }150    func { shouldNotThrowExactlyUnit<T>(it) }151  }152  private fun verifyThrowsAssertionWrapping(thrownException: FooRuntimeException, block: () -> Unit) {153    val thrown = catchThrowable(block)154    thrown!!.shouldBeInstanceOf<AssertionError>()155    thrown.message shouldBe "No exception expected, but a FooRuntimeException was thrown."156    thrown.cause shouldBeSameInstanceAs thrownException157  }158  private fun verifyThrowsExactly(thrownException: Throwable, block: () -> Unit) {159    catchThrowable(block).shouldBeSameInstanceAs(thrownException)160  }161  private fun verifyNoErrorIsThrown(block: () -> Unit) {162    block()163  }164}165private typealias ShouldThrowExactlyMatcher<T> = (() -> Unit) -> T166private typealias ShouldNotThrowExactlyMatcher = (() -> Unit) -> Unit...

1import io.kotest.core.spec.style.FunSpec2import io.kotest.matchers.shouldBe3import io.kotest.matchers.throwable.shouldHaveMessage4import io.kotest.matchers.throwable.shouldHaveMessageStartingWith5import io.kotest.matchers.throwable.shouldHaveStackTraceContaining6import io.kotest.matchers.throwable.shouldHaveType7import io.kotest.matchers.types.shouldBeTypeOf8class StrictThrowableHandlingTest : FunSpec() {9   init {10      test("verify throws assertion wrapping") {11         val someException = IllegalArgumentException("some exception message")12         verifyThrowsAssertionWrapping(someException) {13         }14      }15   }16   private fun verifyThrowsAssertionWrapping(expected: Throwable, actual: () -> Unit) {17      val actualException = kotlin.runCatching { actual() }.exceptionOrNull()18      actualException.shouldNotBeNull()19      actualException.shouldBeTypeOf<AssertionError>()20      actualException.shouldHaveMessageStartingWith("Expected")21      actualException.shouldHaveStackTraceContaining("StrictThrowableHandlingTest.kt")22      actualException.cause.shouldHaveType<AssertionError>()23      actualException.cause.shouldHaveMessage("Expected")24      actualException.cause.cause.shouldHaveType<AssertionError>()25      actualException.cause.cause.shouldHaveMessage("Expected")26      actualException.cause.cause.cause.shouldHaveType<AssertionError>()27      actualException.cause.cause.cause.shouldHaveMessage("Expected")28      actualException.cause.cause.cause.cause.shouldHaveType<AssertionError>()29      actualException.cause.cause.cause.cause.shouldHaveMessage("Expected")30      actualException.cause.cause.cause.cause.cause.shouldHaveType<AssertionError>()31      actualException.cause.cause.cause.cause.cause.shouldHaveMessage("Expected")32      actualException.cause.cause.cause.cause.cause.cause.shouldHaveType<AssertionError>()33      actualException.cause.cause.cause.cause.cause.cause.shouldHaveMessage("Expected")34      actualException.cause.cause.cause.cause.cause.cause.cause.shouldHaveType<AssertionError>()35      actualException.cause.cause.cause.cause.cause.cause.cause.shouldHaveMessage("Expected")

1import com.sksamuel.kotest.throwablehandling.StrictThrowableHandlingTest2import com.sksamuel.kotest.throwablehandling.verifyThrowsAssertionWrapping3verifyThrowsAssertionWrapping<IllegalArgumentException> {4}5import com.sksamuel.kotest.throwablehandling.LenientThrowableHandlingTest6import com.sksamuel.kotest.throwablehandling.verifyThrowsAssertionWrapping7verifyThrowsAssertionWrapping<IllegalArgumentException> {8}9import com.sksamuel.kotest.throwablehandling.StrictThrowableHandlingTest10import com.sksamuel.kotest.throwablehandling.verifyThrowsAssertionWrapping11verifyThrowsAssertionWrapping<IllegalArgumentException> {12}13import com.sksamuel.kotest.throwablehandling.LenientThrowableHandlingTest14import com.sksamuel.kotest.throwablehandling.verifyThrowsAssertionWrapping15verifyThrowsAssertionWrapping<IllegalArgumentException> {16}17import com.sksamuel.kotest.throwablehandling.StrictThrowableHandlingTest18import com.sksamuel.kotest.throwablehandling.verifyThrowsAssertionWrapping19verifyThrowsAssertionWrapping<IllegalArgumentException> {20}21import com.sksamuel.kotest.throwablehandling.LenientThrowableHandlingTest22import com.sksamuel.kotest.throwablehandling.verifyThrowsAssertionWrapping23verifyThrowsAssertionWrapping<IllegalArgumentException> {24}25import com.sksamuel.kotest.throwablehandling.StrictThrowableHandlingTest26import com.sksamuel.kotest.throwablehandling.verifyThrowsAssertionWrapping