How to use FooRuntimeException class of com.sksamuel.kotest.throwablehandling package

Best Kotest code snippet using com.sksamuel.kotest.throwablehandling.FooRuntimeException

CovariantThrowableHandlingTest.kt

Source:CovariantThrowableHandlingTest.kt

...16   init {17      "Should throw" - {18         "Should throw a new exception" - {19            "When no exception is thrown" {20               onShouldThrowMatcher<FooRuntimeException> { shouldThrowMatcher ->21                  verifyNoExceptionThrownError(FooRuntimeException::class) {22                     shouldThrowMatcher { /* No exception is thrown */ }23                  }24               }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            }...

StrictThrowableHandlingTest.kt

Source:StrictThrowableHandlingTest.kt

...13  init {14    "Should throw exactly" - {15      "Should throw a new exception" - {16        "When no exception is thrown" {17          onShouldThrowExactlyMatcher<FooRuntimeException> { shouldThrowExactlyMatcher ->18            verifyNoExceptionThrownError(FooRuntimeException::class) {19              shouldThrowExactlyMatcher { /* No exception is thrown */ }20            }21          }22        }23        "When an exception is thrown, but it's not the right class" {24          val instanceToThrow = NullPointerException()25          onShouldThrowExactlyMatcher<FooRuntimeException> { shouldThrowExactlyMatcher ->26            verifyThrowsWrongExceptionClass(instanceToThrow, FooRuntimeException::class, NullPointerException::class) {27              shouldThrowExactlyMatcher { throw instanceToThrow }28            }29          }30        }31        "When an exception is thrown, but it's the parent class of the right class" {32          val instanceToThrow = ParentException()33          onShouldThrowExactlyMatcher<SubException> { shouldThrowExactlyMatcher ->34            verifyThrowsWrongExceptionClass(instanceToThrow, SubException::class, ParentException::class) {35              shouldThrowExactlyMatcher { throw instanceToThrow }36            }37          }38        }39        "When an exception is thrown, but it's subclass of the right class" {40          val instanceToThrow = SubException()41          onShouldThrowExactlyMatcher<ParentException> { shouldThrowExactlyMatcher ->42            verifyThrowsWrongExceptionClass(instanceToThrow, ParentException::class, SubException::class) {43              shouldThrowExactlyMatcher { throw instanceToThrow }44            }45          }46        }47      }48      "Should throw the thrown exception" - {49        "When an exception is thrown, and it's an Assertion Error (special case) when it's not the expected error" {50          val thrownInstance = AssertionError()51          onShouldThrowExactlyMatcher<FooRuntimeException> { shouldThrowExactlyMatcher ->52            verifyThrowsAssertionErrorInstance(thrownInstance) {53              shouldThrowExactlyMatcher { throw thrownInstance }54            }55          }56        }57      }58      "Should return the thrown exception" - {59        "When an exception is thrown, and it's exactly the right class" {60          val thrownException = FooRuntimeException()61          onShouldThrowExactlyMatcher<FooRuntimeException> { shouldThrowExactlyMatcher ->62            verifyReturnsExactly(thrownException) {63              shouldThrowExactlyMatcher { throw thrownException }64            }65          }66        }67        "When an AssertionError is thrown, and it's exactly the right class" {68          val thrownException = AssertionError()69          onShouldThrowExactlyMatcher<AssertionError> { shouldThrowExactlyMatcher ->70            verifyReturnsExactly(thrownException) {71              shouldThrowExactlyMatcher { throw thrownException }72            }73          }74        }75      }76    }77    "Should not throw exactly" - {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...

AnyThrowableHandlingTest.kt

Source:AnyThrowableHandlingTest.kt

...20          }21        }22        "Should return the thrown instance" - {23          "When an exception is thrown in the code" {24            val instanceToThrow = FooRuntimeException()25            verifyReturnsExactly(instanceToThrow) {26              shouldThrowAnyMatcher { throw instanceToThrow }27            }28          }29        }30      }31    }32    onShouldNotThrowAnyMatcher { shouldNotThrowAnyMatcher ->33      "Should not throw any($shouldNotThrowAnyMatcher)" - {34        "Should throw an exception" - {35          "When any exception is thrown in the code" {36            val exception = FooRuntimeException()37            verifyThrowsAssertionWrapping(exception) {38              shouldNotThrowAnyMatcher { throw exception }39            }40          }41        }42        "Should not throw an exception" - {43          "When no exception is thrown in the code" {44            verifyNoErrorIsThrown {45              shouldNotThrowAnyMatcher { /* Nothing thrown */ }46            }47          }48        }49      }50    }...

ThrowableHandlingScenarioHelpers.kt

Source:ThrowableHandlingScenarioHelpers.kt

1package com.sksamuel.kotest.throwablehandling2class FooRuntimeException : RuntimeException()3open class ParentException : Throwable()4class SubException : ParentException()5fun catchThrowable(block: () -> Any?): Throwable? {6  return try {7    block()8    null9  } catch (t: Throwable) { t }10}...

FooRuntimeException

Using AI Code Generation

1    import com.sksamuel.kotest.throwablehandling.FooRuntimeException2    fun foo() {3        throw FooRuntimeException()4    }5    fun bar() {6        import com.sksamuel.kotest.throwablehandling.FooRuntimeException7        fun foo() {8            throw FooRuntimeException()9        }10        fun bar() {11            throw RuntimeException()12        }13        fun baz() {14            throw Exception()15        }16    }17    fun baz() {18        throw Exception()19    }20    testImplementation("io.kotest:kotest-assertions-core-jvm:4.4.1")

FooRuntimeException

Using AI Code Generation

1    }2    fun `should pass when exception is thrown and expected exception is a subclass of it`() {3    }4    fun `should fail when exception is thrown and expected exception is not a subclass of it`() {5    }6    fun `should fail when exception is not thrown and expected exception is a subclass of it`() {7    }8    fun `should fail when exception is not thrown and expected exception is not a subclass of it`() {9    }10}

FooRuntimeException

Using AI Code Generation

1class FooTest : ShouldSpec() {2  init {3    should("throw exception") {4      shouldThrow<FooRuntimeException> {5        throw FooRuntimeException("foo")6      }7    }8  }9}10"hello world" shouldMatch Regex("hello.*")11"hello world" shouldNotMatch Regex("Hello.*")12"123" shouldContainOnlyDigits()13"123abc" shouldNotContainOnlyDigits()14"abc" shouldContainOnlyLetters()

FooRuntimeException

Using AI Code Generation

1@Throws(FooRuntimeException::class)2fun foo() {3throw FooRuntimeException()4}5}6I have a project that I am working on with a colleague. I have a class that I am trying to test. I am trying to throw an exception in the method I am testing, but I am not sure how to do this. I have tried to use the @Throws annotation, but that doesn't seem to work. Here is my code:Here is the test class:Here is the error I am getting:org.opentest4j.AssertionFailedError: Unexpected exception type thrown ==> expected: <com.sksamuel.kotest.throwablehandling.FooRuntimeException> but was: <kotlin.KotlinNullPointerException>at io.kotest.engine.spec.SpecRunnerKt$executeSpec$1$1$1$1$1.invoke(SpecRunner.kt:129)at io.kotest.engine.spec.SpecRunnerKt$executeSpec$1$1$1$1$1.invoke(SpecRunner.kt)at io.kotest.core.test.TestCaseExecutor$executeTest$1.invokeSuspend(TestCaseExecutor.kt:133)at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:571)at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:750)at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:678)at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:665)I am not sure what I am doing wrong. Any help would be greatly appreciated. Thank you!

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.