How to use errorAndAssertionsScope class of io.kotest.assertions package

Best Kotest code snippet using io.kotest.assertions.errorAndAssertionsScope

all.kt

Source:all.kt

...19 * ```20 */21@ExperimentalKotest22suspend fun <T> all(assertions: suspend () -> T): T {23   if (coroutineContext[AssertionBlockContextElement] != null) { // TODO: refactor all to use errorAndAssertionsScope24      throw IllegalStateException("Assertion block functions one, any, and all are limited to a depth of 1")25   }26   // Handle the edge case of nested calls to this function by only calling throwCollectedErrors in the27   // outermost verifyAll block28   if (errorCollector.getCollectionMode() == ErrorCollectionMode.Soft) return assertions()29   errorCollector.setCollectionMode(ErrorCollectionMode.Soft)30   return try {31      withContext(AssertionBlockContextElement()) {32         assertions()33      }34   } finally {35      // In case if any exception is thrown from assertions block setting errorCollectionMode back to hard36      // so that it won't remain soft for others tests. See https://github.com/kotest/kotest/issues/193237      errorCollector.setCollectionMode(ErrorCollectionMode.Hard)...

errorAndAssertionsScope.kt

Source:errorAndAssertionsScope.kt

...9internal class AssertionBlockContextElement : AbstractCoroutineContextElement(Key) {10   companion object Key : CoroutineContext.Key<AssertionBlockContextElement>11}12/**13 * [errorAndAssertionsScope] runs [block] in a "clean" scope.14 * The original error and assertion counts are stored and set to empty before the [block] is run.15 * Once the block is executed, the result [T], the [Failures], and the number of [Assertions] are stored for return.16 * The original error and assertion counts are replaced into their respective tracking systems [errorCollector] and [assertionCounter].17 *18 * The calling function is responsible for inserting the resultant [Failures] and [Assertions] into [errorCollector] and [assertionCounter] if appropriate.19 *20 * @return The result [T] of the block function, the [Failures] that block had, and the number of [Assertions] executed.21 */22@ExperimentalKotest23internal suspend fun <T> errorAndAssertionsScope(block: suspend () -> T): Triple<Result<T>, Failures, Assertions> {24   if (coroutineContext[AssertionBlockContextElement] != null) {25      throw IllegalStateException("Assertion block functions one, any, and all are limited to a depth of 1")26   }27   val originalFailures = errorCollector.getAndReplace(listOf())28   val originalAssertions = assertionCounter.getAndReset()29   val originalMode = errorCollector.getCollectionMode()30   errorCollector.setCollectionMode(ErrorCollectionMode.Soft)31   val result = runCatching {32      withContext(AssertionBlockContextElement()) {33         block()34      }35   }36   errorCollector.setCollectionMode(originalMode)37   val resultFailures = errorCollector.getAndReplace(originalFailures)...

one.kt

Source:one.kt

...13 * ```14 */15@ExperimentalKotest16suspend fun <T> one(assertions: suspend () -> T): T {17   val (result, failures, assertionsCount) = errorAndAssertionsScope { assertions() }18   assertionCounter.inc(assertionsCount)19   if (assertionsCount < 2) {20      errorCollector.collectOrThrow(failures + failure("One cannot ensure a mutual exclusion with less than two assertions"))21   }22   if (assertionsCount == failures.size + 1) {23      return result.getOrThrow()24   }25   errorCollector.pushErrors(failures)26   val f = when {27      assertionsCount == failures.size -> failure("One expected a single assertion to succeed, but none succeeded.")28      assertionsCount > failures.size + 1 -> failure("One expected a single assertion to succeed, but more than one succeeded.")29      else -> failure("One expected a single assertion to succeed, but there were more failures than assertions.")30   }31   errorCollector.pushErrorAndMaybeThrow(f)...

any.kt

Source:any.kt

...12 * ```13 */14@ExperimentalKotest15suspend fun <T> any(assertions: suspend () -> T): T {16   val (result, failures, assertionCount) = errorAndAssertionsScope { assertions() }17   assertionCounter.inc(assertionCount)18   if (assertionCount > failures.size || failures.isEmpty() && assertionCount == 0) {19      return result.getOrThrow()20   }21   val f = failure("Any expected at least one assertion to succeed but they all failed")22   errorCollector.pushErrors(failures)23   errorCollector.pushErrorAndMaybeThrow(f)24   throw f25}26@ExperimentalKotest27suspend fun <T> any(t: T, assertions: suspend T.(T) -> Unit) = any {28   t.assertions(t)29   t30}...

errorAndAssertionsScope

Using AI Code Generation

1val  errorAndAssertionsScope : ErrorAndAssertionsScope =  ErrorAndAssertionsScope( "test" )2errorAndAssertionsScope .shouldThrow< IllegalArgumentException > {3     throw   IllegalArgumentException ( "test" )4}5errorAndAssertionsScope .shouldThrow< IllegalArgumentException > {6     throw   Exception ( "test" )7}8errorAndAssertionsScope .shouldThrow< IllegalArgumentException > {9     throw   IllegalArgumentException ( "test" )10}11errorAndAssertionsScope .shouldNotThrow< IllegalArgumentException > {12     throw   IllegalArgumentException ( "test" )13}14errorAndAssertionsScope .shouldNotThrow< IllegalArgumentException > {15     throw   Exception ( "test" )16}17errorAndAssertionsScope .shouldNotThrow< IllegalArgumentException > {18     throw   IllegalArgumentException ( "test" )19}20errorAndAssertionsScope .shouldThrow< IllegalArgumentException > {21     throw   IllegalArgumentException ( "test" )22}23errorAndAssertionsScope .shouldThrow< IllegalArgumentException > {24     throw   Exception ( "test" )25}26errorAndAssertionsScope .shouldThrow< IllegalArgumentException > {27     throw   IllegalArgumentException ( "test" )28}29errorAndAssertionsScope .shouldNotThrow< IllegalArgumentException > {30     throw   IllegalArgumentException ( "test" )31}32errorAndAssertionsScope .shouldNotThrow< IllegalArgumentException > {33     throw   Exception ( "test" )34}35errorAndAssertionsScope .shouldNotThrow< IllegalArgumentException > {36     throw   IllegalArgumentException ( "test" )37}38errorAndAssertionsScope .shouldThrow< IllegalArgumentException > {39     throw   IllegalArgumentException ( "test" )40}41errorAndAssertionsScope .shouldThrow< IllegalArgumentException > {42     throw   Exception ( "test" )43}44errorAndAssertionsScope .shouldThrow< IllegalArgumentException > {45     throw   IllegalArgumentException ( "test" )46}47errorAndAssertionsScope .shouldNotThrow< IllegalArgumentException > {48     throw   IllegalArgumentException ( "test" )49}50errorAndAssertionsScope .shouldNotThrow< IllegalArgumentException > {51     throw   Exception ( "test" )52}53errorAndAssertionsScope .shouldNotThrow< IllegalArgumentException > {54     throw   IllegalArgumentException ( "test" )55}56errorAndAssertionsScope .shouldThrow< IllegalArgumentException > {57     throw   IllegalArgumentException ( "test" )58}59errorAndAssertionsScope .shouldThrow< IllegalArgumentException > {60     throw   Exception ( "test" )61}62errorAndAssertionsScope .shouldThrow< IllegalArgumentException > {63     throw   IllegalArgumentException ( "test" )64}65errorAndAssertionsScope .shouldNotThrow< IllegalArgumentException > {66     throw   IllegalArgumentException ( "test" )67}

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.