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

...93         "Should throw an assertion error wrapping the thrown exception" - {94            "When it's an instance of the right class" {95               val thrownException = FooRuntimeException()96               onShouldNotThrowMatcher<FooRuntimeException> { shouldNotThrowMatcher ->97                  verifyThrowsAssertionWrapping(thrownException) {98                     shouldNotThrowMatcher { throw thrownException }99                  }100               }101            }102            "When it's a subclass of the right class" {103               val thrownException = SubException()104               onShouldNotThrowMatcher<ParentException> { shouldNotThrowMatcher ->105                  verifyThrowsAssertionWrapping(thrownException) {106                     shouldNotThrowMatcher { throw thrownException }107                  }108               }109            }110         }111         "Should throw the thrown exception" - {112            "When it's not an instance nor subclass of the right class" {113               val thrownException = FooRuntimeException()114               onShouldNotThrowMatcher<ParentException> { shouldNotThrowMatcher ->115                  verifyThrowsExactly(thrownException) {116                     shouldNotThrowMatcher { throw thrownException }117                  }118               }119            }120            "When it's an instance of the parent class of the right class" {121               val thrownException = ParentException()122               onShouldNotThrowMatcher<SubException> { shouldNotThrowMatcher ->123                  verifyThrowsExactly(thrownException) {124                     shouldNotThrowMatcher { throw thrownException }125                  }126               }127            }128         }129         "Should not throw an exception" - {130            "When no exception is thrown" {131               onShouldNotThrowMatcher<ParentException> { shouldNotThrowMatcher ->132                  val thrown = catchThrowable {133                     shouldNotThrowMatcher { /* Nothing thrown */ }134                  }135                  thrown shouldBe null136               }137            }138         }139      }140      "should throw with message" - {141         "When the correct exception is thrown, but the message is wrong" {142            onShouldThrowWithMessageMatcher<Exception>("foo") { shouldThrowMatcher ->143               verifyThrowsWrongExceptionMessage("foo", "bar") {144                  shouldThrowMatcher { throw Exception("bar") }145               }146            }147         }148         "Exception class type should have priority in assertion" {149            val instanceToThrow = Exception("foo")150            runCatching {151               shouldThrowWithMessage<RuntimeException>("bar") {152                  throw instanceToThrow153               }154            }155               .exceptionOrNull() shouldBe AssertionError("Expected exception java.lang.RuntimeException but a Exception was thrown instead.")156         }157      }158   }159   private fun <T> onShouldThrowWithMessageMatcher(message: String, func: (ShouldThrowMatcher<T>) -> Unit) {160      func { shouldThrowUnitWithMessage(message, it) }161      func { shouldThrowWithMessage(message, it) }162   }163   private inline fun <reified T : Throwable> onShouldThrowMatcher(func: (ShouldThrowMatcher<T>) -> Unit) {164      func(::shouldThrowUnit)165      func { shouldThrow(it) }166   }167   private fun verifyNoExceptionThrownError(expectedClass: KClass<*>, block: () -> Unit) {168      val throwable = catchThrowable(block)169      throwable.shouldBeInstanceOf<AssertionError>()170      throwable.message shouldBe "Expected exception ${expectedClass.qualifiedName} but no exception was thrown."171   }172   private fun verifyThrowsAssertionErrorInstance(assertionErrorInstance: AssertionError, block: () -> Unit) {173      val throwable = catchThrowable(block)174      (throwable === assertionErrorInstance).shouldBeTrue()175   }176   private fun verifyThrowsWrongExceptionClass(177      thrownInstance: Throwable,178      expectedClass: KClass<*>,179      incorrectClass: KClass<*>,180      block: () -> Unit181   ) {182      val throwable = catchThrowable(block)183      throwable.shouldBeInstanceOf<AssertionError>()184      throwable.message shouldBe "Expected exception ${expectedClass.qualifiedName} but a ${incorrectClass.simpleName} was thrown instead."185      (throwable.cause === thrownInstance).shouldBeTrue()186   }187   private fun verifyThrowsWrongExceptionMessage(188      expectedMessage: String,189      actualMessage: String,190      block: () -> Unit191   ) {192      val throwable = catchThrowable(block)193      throwable.shouldBeInstanceOf<AssertionError>()194      throwable.message shouldBe "Expected exception message $expectedMessage but was $actualMessage instead."195   }196   private fun verifyReturnsExactly(thrownException: Throwable, block: () -> Any?) {197      val actualReturn = block()198      (thrownException === actualReturn).shouldBeTrue()199   }200   private inline fun <reified T : Throwable> onShouldNotThrowMatcher(func: (ShouldNotThrowMatcher<T>) -> Unit) {201      func { shouldNotThrowUnit<T> { it() } }202      func { shouldNotThrow<T>(it) }203   }204   private fun verifyThrowsAssertionWrapping(exception: Throwable, block: () -> Unit) {205      val thrown = catchThrowable(block)206      thrown.shouldBeInstanceOf<AssertionError>()207      thrown.message shouldBe "No exception expected, but a ${exception::class.simpleName} was thrown."208      thrown.cause shouldBeSameInstanceAs exception209   }210   private fun verifyThrowsExactly(exception: Throwable, block: () -> Unit) {211      val thrown = catchThrowable(block)212      thrown shouldBeSameInstanceAs exception213   }214}215private typealias ShouldThrowMatcher<T> = (() -> Unit) -> T216private typealias ShouldNotThrowMatcher<T> = (() -> Unit) -> Unit...

1import com.sksamuel.kotest.throwablehandling.CovariantThrowableHandlingTest2import io.kotest.matchers.throwable.shouldHaveMessage3import io.kotest.matchers.throwable.shouldHaveMessageContaining4import io.kotest.matchers.throwable.shouldHaveMessageStartingWith5import io.kotest.matchers.throwable.shouldHaveMessageEndingWith6import io.kotest.matchers.throwable.shouldHaveMessageMatching7import io.kotest.matchers.throwable.shouldHaveMessageNotMatching8import io.kotest.matchers.throwable.shouldHaveCause9import io.kotest.matchers.throwable.shouldHaveCauseInstanceOf10import io.kotest.matchers.throwable.shouldHaveCauseWithMessage11import io.kotest.matchers.throwable.shouldHaveCauseWithMessageContaining12import io.kotest.matchers.throwable.shouldHaveCauseWithMessageStartingWith13import io.kotest.matchers.throwable.shouldHaveCauseWithMessageEndingWith14import io.kotest.matchers.throwable.shouldHaveCauseWithMessageMatching15import io.kotest.matchers.throwable.shouldHaveCauseWithMessageNotMatching16import io.kotest.matchers.throwable.shouldHaveSuppressedException17import io.kotest.matchers.throwable.shouldHaveSuppressedExceptionInstanceOf18import io.kotest.matchers.throwable.shouldHaveSuppressedExceptionWithMessage19import io.kotest.matchers.throwable.shouldHaveSuppressedExceptionWithMessageContaining20import io.kotest.matchers.throwable.shouldHaveSuppressedExceptionWithMessageStartingWith21import io.kotest.matchers.throwable.shouldHaveSuppressedExceptionWithMessageEndingWith22import io.kotest.matchers.throwable.shouldHaveSuppressedExceptionWithMessageMatching23import io.kotest.matchers.throwable.shouldHaveSuppressedExceptionWithMessageNotMatching24import io.kotest.matchers.throwable.shouldHaveSuppressedExceptions25import io.kotest.matchers.throwable.shouldHaveSuppressedExceptionsInstanceOf26import io.kotest.matchers.throwable.shouldHaveSuppressedExceptionsWithMessage27import io.kotest.matchers.throwable.shouldHaveSuppressedExceptionsWithMessageContaining28import io.kotest.matchers.throwable.shouldHaveSuppressedExceptionsWithMessageStartingWith29import io.kotest.matchers.throwable.shouldHaveSuppressedExceptionsWithMessageEndingWith30import io.kotest.matchers.throwable.shouldHaveSuppressedExceptionsWithMessageMatching31import io.kotest.match

1public void verifyThrowsAssertionWrapping() {2    verifyThrowsAssertionWrapping(3            () -> { throw new RuntimeException("hello"); },4    );5}6public void verifyThrowsAssertionWrapping() {7    verifyThrowsAssertionWrapping(8            () -> { throw new RuntimeException("hello"); },9    );10}11public void verifyThrowsAssertionWrapping() {12    verifyThrowsAssertionWrapping(13            () -> { throw new RuntimeException("hello"); },14    );15}16public void verifyThrowsAssertionWrapping() {17    verifyThrowsAssertionWrapping(18            () -> { throw new RuntimeException("hello"); },19    );20}21public void verifyThrowsAssertionWrapping() {22    verifyThrowsAssertionWrapping(23            () -> { throw new RuntimeException("hello"); },24    );25}26public void verifyThrowsAssertionWrapping() {27    verifyThrowsAssertionWrapping(28            () -> { throw new RuntimeException("hello"); },29    );30}31public void verifyThrowsAssertionWrapping() {32    verifyThrowsAssertionWrapping(33            () -> { throw new RuntimeException("hello

1    verifyThrowsAssertionWrapping<NumberFormatException> {2        "abc".toInt()3    }4    verifyThrowsAssertionWrapping<ArithmeticException> {5    }6    verifyThrowsAssertionWrapping<ArithmeticException> {7    }8    verifyThrowsAssertionWrapping<ArithmeticException> {9    }10    verifyThrowsAssertionWrapping<ArithmeticException> {11    }12    verifyThrowsAssertionWrapping<ArithmeticException> {13    }14    verifyThrowsAssertionWrapping<ArithmeticException> {15    }