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

...25            }26            "When an exception is thrown, but it's not the right class" {27               val instanceToThrow = NullPointerException()28               onShouldThrowMatcher<FooRuntimeException> { shouldThrowMatcher ->29                  verifyThrowsWrongExceptionClass(30                     instanceToThrow,31                     FooRuntimeException::class,32                     NullPointerException::class33                  ) {34                     shouldThrowMatcher { throw instanceToThrow }35                  }36               }37            }38            "When an exception is thrown, but it's the parent class of the right class" {39               val instanceToThrow = ParentException()40               onShouldThrowMatcher<SubException> { shouldThrowMatcher ->41                  verifyThrowsWrongExceptionClass(instanceToThrow, SubException::class, ParentException::class) {42                     shouldThrowMatcher { throw instanceToThrow }43                  }44               }45            }46         }47         "Should throw the thrown exception" - {48            "When an exception is thrown, but it's an Assertion Error (special case) when it's not expected" {49               val thrownInstance = AssertionError()50               onShouldThrowMatcher<FooRuntimeException> { shouldThrowMatcher ->51                  verifyThrowsAssertionErrorInstance(thrownInstance) {52                     shouldThrowMatcher { throw thrownInstance }53                  }54               }55            }56         }57         "Should return the thrown exception" - {58            "When an exception is thrown and it's exactly the right class" {59               val thrownException = FooRuntimeException()60               onShouldThrowMatcher<FooRuntimeException> { shouldThrowMatcher ->61                  verifyReturnsExactly(thrownException) {62                     shouldThrowMatcher { throw thrownException }63                  }64               }65            }66            "When an exception is thrown and it's a subclass of the right class" {67               val thrownException = SubException()68               onShouldThrowMatcher<ParentException> { shouldThrowMatcher ->69                  verifyReturnsExactly(thrownException) {70                     shouldThrowMatcher { throw thrownException }71                  }72               }73            }74            "When an AssertionError is thrown and it's exactly the right class" {75               val thrownException = AssertionError()76               onShouldThrowMatcher<AssertionError> { shouldThrowMatcher ->77                  verifyReturnsExactly(thrownException) {78                     shouldThrowMatcher { throw thrownException }79                  }80               }81            }82            "When a subclass of AssertionError is thrown, and we're expecting an AssertionError" {83               val thrownException = AssertionErrorSubclass()84               onShouldThrowMatcher<AssertionError> { shouldThrowMatcher ->85                  verifyReturnsExactly(thrownException) {86                     shouldThrowMatcher { throw thrownException }87                  }88               }89            }90         }91      }92      "Should not throw" - {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: () -> Unit...

1    fun `verifyThrowsWrongExceptionClass method of com.sksamuel.kotest.throwablehandling.CovariantThrowableHandlingTest class`() {2        verifyThrowsWrongExceptionClass()3    }4    fun `verifyThrowsWrongExceptionClass method of com.sksamuel.kotest.throwablehandling.CovariantThrowableHandlingTest class`() {5        verifyThrowsWrongExceptionClass()6    }7    fun `verifyThrowsWrongExceptionClass method of com.sksamuel.kotest.throwablehandling.CovariantThrowableHandlingTest class`() {8        verifyThrowsWrongExceptionClass()9    }10    fun `verifyThrowsWrongExceptionClass method of com.sksamuel.kotest.throwablehandling.CovariantThrowableHandlingTest class`() {11        verifyThrowsWrongExceptionClass()12    }13}

1@DisplayName("Covariant Throwable Handling Test") class CovariantThrowableHandlingTest { @Test fun `verifyThrowsWrongExceptionClass`() { verifyThrowsWrongExceptionClass() } }2@DisplayName("Covariant Throwable Handling Test") class CovariantThrowableHandlingTest { @Test fun `verifyThrowsWrongExceptionClass`() { verifyThrowsWrongExceptionClass() } }3@DisplayName("Covariant Throwable Handling Test") class CovariantThrowableHandlingTest { @Test fun `verifyThrowsWrongExceptionClass`() { verifyThrowsWrongExceptionClass() } }4@DisplayName("Covariant Throwable Handling Test") class CovariantThrowableHandlingTest { @Test fun `verifyThrowsWrongExceptionClass`() { verifyThrowsWrongExceptionClass() } }5@DisplayName("Covariant Throwable Handling Test") class CovariantThrowableHandlingTest { @Test fun `verifyThrowsWrongExceptionClass`() { verifyThrowsWrongExceptionClass() } }6@DisplayName("Covariant Throwable Handling Test") class CovariantThrowableHandlingTest { @Test fun `verifyThrowsWrongExceptionClass`() { verifyThrowsWrongExceptionClass() } }7@DisplayName("Covariant Throwable Handling Test") class CovariantThrowableHandlingTest { @Test fun `verifyThrowsWrongExceptionClass`() { verifyThrowsWrongExceptionClass() } }8@DisplayName("Covariant Throwable Handling Test") class CovariantThrowableHandlingTest { @Test fun `verifyThrowsWrongExceptionClass`() { verifyThrowsWrongExceptionClass() } }