How to use createAssertionError method of io.kotest.assertions.Exceptions class

Best Kotest code snippet using io.kotest.assertions.Exceptions.createAssertionError

StrictThrowableHandling.kt

Source:StrictThrowableHandling.kt

...98   return when {99      thrownThrowable == null -> throw failure("Expected exception ${T::class.bestName()} but no exception was thrown.")100      thrownThrowable::class == expectedExceptionClass -> thrownThrowable as T  // This should be before `is AssertionError`. If the user is purposefully trying to verify `shouldThrow<AssertionError>{}` this will take priority101      thrownThrowable is AssertionError -> throw thrownThrowable102      else -> throw stacktraces.cleanStackTrace(Exceptions.createAssertionError(clueContextAsString() + "Expected exception ${expectedExceptionClass.bestName()} but a ${thrownThrowable::class.simpleName} was thrown instead."))103   }104}105/**106 * Verifies that a block of code doesn't throw a Throwable of type [T], not including subclasses of [T]107 *108 * Use this function to wrap a block of code that you'd like to verify whether it throws [T] (not including) or not.109 * If [T] is thrown, this will thrown an [AssertionError]. If anything else is thrown, the throwable will be propagated.110 * This is done so that no unexpected error is silently ignored.111 *112 *113 * This function won't include subclasses of [T]. For example, if you test for [java.io.IOException] and the code block114 * throws [java.io.FileNotFoundException], propagate the [java.io.FileNotFoundException] instead of wrapping it in an AssertionError.115 *116 * If you wish to test [T] and subclasses, use [shouldNotThrow].117 *118 * If you don't care about the thrown exception, use [shouldNotThrowAny]119 *120 * **Attention to assignment operations**:121 *122 * When doing an assignment to a variable, the code won't compile, because an assignment is not of type [Any], as required123 * by [block]. If you need to test that an assignment doesn't throw a [Throwable], use [shouldNotThrowExactlyUnit] or it's variations.124 *125 * ```126 *     val thrown: FooException = shouldThrowExactly<FooException> {127 *         // Code that we expect to throw FooException128 *         throw FooException()129 *     }130 * ```131 *132 * @see [shouldNotThrowExactlyUnit]133 *134 */135inline fun <reified T : Throwable> shouldNotThrowExactly(block: () -> Any?) {136   assertionCounter.inc()137   val thrown = try {138      block()139      return140   } catch (t: Throwable) {141      t142   }143   if (thrown::class == T::class) throw stacktraces.cleanStackTrace(Exceptions.createAssertionError(clueContextAsString() + "No exception expected, but a ${thrown::class.simpleName} was thrown."))144   throw thrown145}...

CovariantThrowableHandling.kt

Source:CovariantThrowableHandling.kt

...97   return when (thrownThrowable) {98      null -> throw failure("Expected exception ${expectedExceptionClass.bestName()} but no exception was thrown.")99      is T -> thrownThrowable               // This should be before `is AssertionError`. If the user is purposefully trying to verify `shouldThrow<AssertionError>{}` this will take priority100      is AssertionError -> throw thrownThrowable101      else -> throw stacktraces.cleanStackTrace(Exceptions.createAssertionError(clueContextAsString() + "Expected exception ${expectedExceptionClass.bestName()} but a ${thrownThrowable::class.simpleName} was thrown instead."))102   }103}104/**105 * Verifies that a block of code will not throw a Throwable of type [T] or subtypes106 *107 * Use this function to wrap a block of code that you'd like to verify whether it throws [T] (or subclasses) or not.108 * If [T] is thrown, this will thrown an [AssertionError]. If anything else is thrown, the throwable will be propagated.109 * This is done so that no unexpected error is silently ignored.110 *111 * This function will include all subclasses of [T]. For example, if you test for [java.io.IOException] and the code block112 * throws [java.io.FileNotFoundException], this will also throw an AssertionError instead of propagating the [java.io.FileNotFoundException]113 * directly.114 *115 * If you wish to test for a specific class strictly (excluding subclasses), use [shouldNotThrowExactly] instead.116 *117 * If you don't care about the thrown exception, use [shouldNotThrowAny].118 *119 * **Attention to assignment operations**:120 *121 * When doing an assignment to a variable, the code won't compile, because an assignment is not of type [Any], as required122 * by [block]. If you need to test that an assignment doesn't throw a [Throwable], use [shouldNotThrowUnit] or it's variations.123 *124 * ```125 *     val thrownException: FooException = shouldThrow<FooException> {126 *         throw FooException() // Fails127 *     }128 * ```129 *130 * @see [shouldNotThrowUnit]131 */132inline fun <reified T : Throwable> shouldNotThrow(block: () -> Any?) {133   assertionCounter.inc()134   val thrown = try {135      block()136      return137   } catch (e: Throwable) {138      e139   }140   if (thrown is T)141      throw stacktraces.cleanStackTrace(Exceptions.createAssertionError(clueContextAsString() + "No exception expected, but a ${thrown::class.simpleName} was thrown."))142   throw thrown143}...

AnyThrowableHandling.kt

Source:AnyThrowableHandling.kt

...94      return block()95   } catch (e: Throwable) {96      e97   }98   throw stacktraces.cleanStackTrace(Exceptions.createAssertionError(clueContextAsString() + "No exception expected, but a ${thrownException::class.simpleName} was thrown."))99}100/**101 * Verifies that a block of code throws any [Throwable] with given [message].102 *103 * @see [shouldNotThrowMessage]104 * */105inline fun <T> shouldThrowMessage(message: String, block: () -> T) {106   assertionCounter.inc()107   val thrownException = try {108      block()109      null110   } catch (e: Throwable) {111      e112   }113   thrownException ?: throw failure(114      "Expected a throwable with message ${StringShow.show(message).value} but nothing was thrown".trimMargin()115   )116   if (thrownException.message != message) {117      throw stacktraces.cleanStackTrace(Exceptions.createAssertionError(clueContextAsString() + "Expected a throwable with message ${StringShow.show(message).value} but got a throwable with message ${thrownException.message.show().value}".trimMargin()))118   }119}120/**121 * Verifies that a block of code does not throws any [Throwable] with given [message].122* */123inline fun <T> shouldNotThrowMessage(message: String, block: () -> T) {124   assertionCounter.inc()125   val thrownException = try {126      block()127      null128   } catch (e: Throwable) {129      e130   }131   if (thrownException != null && thrownException.message == message)132      throw stacktraces.cleanStackTrace(Exceptions.createAssertionError(clueContextAsString() + """Expected no exception with message: "$message"133                             |but a ${thrownException::class.simpleName} was thrown with given message""".trimMargin()))134}...

failures.kt

Source:failures.kt

...7 * Creates the most appropriate error from the given message, wrapping in clue context(s)8 * if any are set.9 */10fun failure(message: String): AssertionError =11  stacktraces.cleanStackTrace(Exceptions.createAssertionError(clueContextAsString() + message))12/**13 * Creates a [Throwable] from expected and actual values, appending clue context(s)14 * if any are set. The error message is generated in the intellij 'diff' format.15 *16 * This function should be used for "comparison" failures, such as "a" shouldBe "b".17 * For other types of errors (eg timeout, or expected exception but none was thrown) prefer18 * the failure methods that take an explicit message.19 *20 * The given values should have already been [Printed] using the Show typeclass.21 *22 * If the platform supports stack traces,23 * then the stack is cleaned of `io.kotest` lines.24 */25fun failure(expected: Expected, actual: Actual, prependMessage: String = ""): Throwable {26  return stacktraces.cleanStackTrace(27     Exceptions.createAssertionError(28        prependMessage + clueContextAsString() + intellijFormatError(expected, actual)29     )30  )31}32/**33 * Returns a message formatted appropriately for intellij to show a diff.34 *35 * This is the format intellij requires to recognize:36 * https://github.com/JetBrains/intellij-community/blob/5422868682d7eb8511dda02cf615ff375f5b0324/java/java-runtime/src/com/intellij/rt/execution/testFrameworks/AbstractExpectedPatterns.java37 *38 * From the above link:39 * private static final Pattern ASSERT_EQUALS_PATTERN = Pattern.compile("expected:<(.*)> but was:<(.*)>", Pattern.DOTALL | Pattern.CASE_INSENSITIVE);40 */41fun intellijFormatError(expected: Expected, actual: Actual): String {...

clues.kt

Source:clues.kt

...22      errorCollector.pushClue { clue.value.toString() }23      return thunk()24   // this is a special control exception used by coroutines25   } catch (t: TimeoutCancellationException) {26      throw Exceptions.createAssertionError(clueContextAsString() + (t.message ?: ""), t)27   } finally {28      errorCollector.popClue()29   }30}31/**32 * Similar to `withClue`, but will add `this` as a clue to the assertion error message in case an assertion fails.33 * Can be nested, the error message will contain all available clues.34 *35 * @param block the code with assertions to be executed36 * @return the return value of the supplied [block]37 */38inline fun <T : Any?, R> T.asClue(block: (T) -> R): R = withClue(lazy { this.toString() }) { block(this) }39inline fun <T : Any?> Iterable<T>.forEachAsClue(action: (T) -> Unit) = forEach { element ->40   element.asClue {...

MultiAssertionError.kt

Source:MultiAssertionError.kt

...36         }37      }38   }39  errors.firstOrNull { it.cause != null }40  return stacktraces.cleanStackTrace(Exceptions.createAssertionError(clueContextAsString() + message))41}...

Exceptions.kt

Source:Exceptions.kt

...4   /**5    * Creates an [AssertionError] from the given message. If the platform supports nested exceptions, the cause6    * is set to the given [cause].7    */8   actual fun createAssertionError(message: String, cause: Throwable?): AssertionError = AssertionError(message, cause)9   /**10    * Creates an [AssertionError] from the given message and expected and actual values.11    *12    * The exception type is13    *14    *15    * See https://ota4j-team.github.io/opentest4j/docs/1.0.0/api/org/opentest4j/AssertionFailedError.html16    *17    */18   actual fun createAssertionError(19      message: String,20      cause: Throwable?,21      expected: Expected,22      actual: Actual23   ): Throwable = AssertionFailedError(message, cause, expected.value.value, actual.value.value)24}25/**26 * This is our extension of the opentest4j error type which adds the interface [ComparisonError] which27 * is the Kotest multiplatform interface for errors that expose expected and actual values.28 */29class AssertionFailedError(30   message: String,31   cause: Throwable?,32   override val expectedValue: String,...

errors.kt

Source:errors.kt

...26   val message = when (e) {27      is AssertionError -> e.message28      else -> e.toString()29   }30   return stacktraces.cleanStackTrace(Exceptions.createAssertionError(clueContextAsString() + "Test failed for $params with error $message"))31}32@PublishedApi33internal fun forNoneError(headers: List<String>, values: List<*>): Throwable {34   val params = headers.zip(values).joinToString(", ")35   return failure("Test passed for $params but expected failure")36}

createAssertionError

Using AI Code Generation

1val exception = createAssertionError("Expected 3, but was 4")2println(exception.message)3val exception = createAssertionError("Expected 3, but was 4", cause = Exception())4println(exception.message)5val exception = createAssertionError("Expected 3, but was 4", cause = Exception(), expected = "3", actual = "4")6println(exception.message)7val exception = createAssertionError("Expected 3, but was 4", cause = Exception(), expected = "3", actual = "4", showDiff = true)8println(exception.message)9val exception = createAssertionError("Expected 3, but was 4", cause = Exception(), expected = "3", actual = "4", showDiff = false)10println(exception.message)11val exception = createAssertionError("Expected 3, but was 4", cause = Exception(), expected = "3", actual = "4", showDiff = false, diff = "diff")12println(exception.message)13val exception = createAssertionError("Expected 3, but was 4", cause = Exception(), expected = "3", actual = "4", showDiff = false, diff = "diff", diffColorFn = { it })14println(exception.message)15val exception = createAssertionError("Expected 3, but was 4", cause = Exception(), expected = "3", actual = "4", showDiff = false, diff = "diff", diffColorFn = { it }, renderers = listOf())16println(exception.message)17val exception = createAssertionError("Expected 3, but was 4", cause = Exception(), expected = "3", actual = "4", showDiff = false, diff = "diff", diffColorFn = { it },

createAssertionError

Using AI Code Generation

1    Assertions.createAssertionError("message", cause, sourceRef)2    Assertions.createAssertionError("message", sourceRef)3    Assertions.createAssertionError(cause, sourceRef)4    Assertions.createAssertionError(sourceRef)5    Exceptions.createAssertionError("message", cause, sourceRef)6    Exceptions.createAssertionError("message", sourceRef)7    Exceptions.createAssertionError(cause, sourceRef)8    Exceptions.createAssertionError(sourceRef)9    Assertions.createAssertionError("message", cause, sourceRef)10    Assertions.createAssertionError("message", sourceRef)11    Assertions.createAssertionError(cause, sourceRef)12    Assertions.createAssertionError(sourceRef)13    Exceptions.createAssertionError("message", cause, sourceRef)14    Exceptions.createAssertionError("message", sourceRef)15    Exceptions.createAssertionError(cause, sourceRef)16    Exceptions.createAssertionError(sourceRef)17    Assertions.createAssertionError("message", cause, sourceRef)18    Assertions.createAssertionError("message", sourceRef)19    Assertions.createAssertionError(cause, sourceRef)20    Assertions.createAssertionError(sourceRef)21    Exceptions.createAssertionError("message", cause, sourceRef)22    Exceptions.createAssertionError("message", sourceRef)23    Exceptions.createAssertionError(cause, sourceRef)24    Exceptions.createAssertionError(sourceRef)25    Assertions.createAssertionError("message", cause, sourceRef)26    Assertions.createAssertionError("message", sourceRef)27    Assertions.createAssertionError(cause, sourceRef)28    Assertions.createAssertionError(sourceRef)29    Exceptions.createAssertionError("message", cause, sourceRef)30    Exceptions.createAssertionError("message", sourceRef)31    Exceptions.createAssertionError(cause, sourceRef)32    Exceptions.createAssertionError(sourceRef)

createAssertionError

Using AI Code Generation

1result.shouldBeLessThan(5)2}3}4}5at io.kotest.assertions.ExceptionsKt.createAssertionError(Exceptions.kt:26)6at io.kotest.assertions.AssertionKt.assertion(Assertion.kt:25)7at io.kotest.assertions.AssertionKt.assertion$default(Assertion.kt:24)8at io.kotest.matchers.comparables.shouldBeLessThan(Comparables.kt:45)9at io.kotest.matchers.comparables.shouldBeLessThan$default(Comparables.kt:44)10at com.kotest.assertions.ExceptionAssertionsKtTest.should throw assertion error when assertion fails(ExceptionAssertionsKtTest.kt:22)11at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)12at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)13at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)14at java.lang.reflect.Method.invoke(Method.java:498)15at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)16at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)17at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)18at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)19at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:26)20at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)21at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)22at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)23at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)24at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)25at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)26at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)27at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)28at org.junit.runners.ParentRunner.run(ParentRunner.java:363)29at org.junit.runner.JUnitCore.run(JUnitCore.java:137)

createAssertionError

Using AI Code Generation

1val ex = Exceptions.createAssertionError(message)2println(ex.message)3val cause = NullPointerException()4val ex = Exceptions.createAssertionError(message, cause)5println(ex.message)6println(ex.cause)7val cause = NullPointerException()8val ex = Exceptions.createAssertionError(message, cause, true, true)9println(ex.message)10println(ex.cause)11println(ex.suppressed)12Recommended Posts: Kotlin | Exceptions.createIllegalStateException() method

createAssertionError

Using AI Code Generation

1class MyTest : StringSpec({2   "test" {3   }4})5class MyTest : StringSpec({6   "test" {7      if(a != b) {8         throw createAssertionError("a should be equal to b")9      }10   }11})

createAssertionError

Using AI Code Generation

1    throw Exceptions.createAssertionError(message)2}3fun main() {4    shouldThrow<AssertionError> {5        assertEquals(1, 2)6    }7}8fun assertEquals(expected: Int, actual: Int) {9    throw Exceptions.createAssertionError(message)10}11fun main() {12    shouldThrow<AssertionError> {13        assertEquals(1, 2)14    }15    shouldThrow<AssertionError> {16        assertEquals(1, 2)17    }.message shouldBe "Expected 2 to be 1"18}19fun assertEquals(expected: Int, actual: Int) {20    throw Exceptions.createAssertionError(message)21}22fun main() {23    shouldNotThrow<AssertionError> {24        assertEquals(1, 1)25    }26}

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.