How to use ErrorCollector.collectiveError method of io.kotest.assertions.BasicErrorCollector class

1package io.kotest.assertions2import io.kotest.mpp.stacktraces3expect val errorCollector: ErrorCollector4/**5 * Specifies an assertion mode:6 * - Hard: assertion errors are thrown immediately7 * - Soft: assertion errors are collected and throw together8 */9enum class ErrorCollectionMode {10   Soft, Hard11}12typealias Clue = () -> String13interface ErrorCollector {14   fun getCollectionMode(): ErrorCollectionMode15   fun setCollectionMode(mode: ErrorCollectionMode)16   /**17    * Returns the errors accumulated in the current context.18    */19   fun errors(): List<Throwable>20   /**21    * Adds the given error to the current context.22    */23   fun pushError(t: Throwable)24   /**25    * Clears all errors from the current context.26    */27   fun clear()28   fun pushClue(clue: Clue)29   fun popClue()30   /**31    * Returns the current clue context.32    * That is all the clues nested to this point.33    */34   fun clueContext(): List<Clue>35}36object NoopErrorCollector : ErrorCollector {37   override fun getCollectionMode(): ErrorCollectionMode = ErrorCollectionMode.Hard38   override fun setCollectionMode(mode: ErrorCollectionMode) {39   }40   override fun errors(): List<Throwable> = emptyList()41   override fun pushError(t: Throwable) {42   }43   override fun clear() {44   }45   override fun pushClue(clue: Clue) {46   }47   override fun popClue() {48   }49   override fun clueContext(): List<Clue> = emptyList()50}51open class BasicErrorCollector : ErrorCollector {52   protected val failures = mutableListOf<Throwable>()53   protected var mode = ErrorCollectionMode.Hard54   protected val clues = mutableListOf<Clue>()55   override fun getCollectionMode(): ErrorCollectionMode = mode56   override fun setCollectionMode(mode: ErrorCollectionMode) {57      this.mode = mode58   }59   override fun pushClue(clue: Clue) {60      clues.add(0, clue)61   }62   override fun popClue() {63      clues.removeAt(0)64   }65   override fun clueContext(): List<Clue> = clues.reversed()66   override fun pushError(t: Throwable) {67      failures.add(t)68   }69   override fun errors(): List<Throwable> = failures.toList()70   override fun clear() = failures.clear()71}72internal fun ErrorCollector.getAndReplace(errors: Collection<Throwable>): List<Throwable> {73   val old = errors()74   clear()75   errors.forEach { pushError(it) }76   return old77}78fun clueContextAsString() = errorCollector.clueContext().let {79   if (it.isEmpty()) "" else it.joinToString("\n", postfix = "\n") { f -> f.invoke() }80}81/**82 * If we are in "soft assertion mode" will add this throwable to the83 * list of throwables for the current execution. Otherwise will84 * throw immediately.85 */86fun ErrorCollector.collectOrThrow(error: Throwable) {87   when (getCollectionMode()) {88      ErrorCollectionMode.Soft -> pushError(error)89      ErrorCollectionMode.Hard -> throw error90   }91}92fun ErrorCollector.pushErrors(errors: Collection<Throwable>) {93   errors.forEach {94      pushError(it)95   }96}97fun ErrorCollector.collectOrThrow(errors: Collection<Throwable>) {98   pushErrors(errors)99   if (getCollectionMode() == ErrorCollectionMode.Hard) {100      throwCollectedErrors()101   }102}103/**104 * All errors currently collected in the [ErrorCollector] are throw as a single [MultiAssertionError].105 */106fun ErrorCollector.throwCollectedErrors() {107   collectiveError()?.let { throw it }108}109/**110 * All errors currently collected in the [ErrorCollector] are returned as a single [MultiAssertionError].111 */112fun ErrorCollector.collectiveError(): AssertionError? {113   val failures = errors()114   clear()115   return if (failures.isNotEmpty()) {116      if (failures.size == 1) {117         AssertionError(failures[0].message).also {118            stacktraces.cleanStackTrace(it)119         }120      } else {121         MultiAssertionError(failures).also {122            stacktraces.cleanStackTrace(it) // cleans the creation of MultiAssertionError123         }124      }125   } else null126}127inline fun <reified T> ErrorCollector.runWithMode(mode: ErrorCollectionMode, block: () -> T): T =128   getCollectionMode().let { original ->129      setCollectionMode(mode)130      try {131         block()132      } finally {133         setCollectionMode(original)134      }135   }...

1fun <T> T.shouldBe(expected: T, message: String? = null) = this shouldBe expected2fun <T> T.shouldNotBe(expected: T, message: String? = null) = this shouldNotBe expected3fun <T> T.shouldBeNull(message: String? = null) = this shouldBe null4fun <T> T.shouldNotBeNull(message: String? = null) = this shouldNotBe null5fun <T> T.shouldBeSameInstanceAs(expected: T, message: String? = null) = this shouldBeSameInstanceAs expected6fun <T> T.shouldNotBeSameInstanceAs(expected: T, message: String? = null) = this shouldNotBeSameInstanceAs expected7fun <T> T.shouldBeInstanceOf(expected: Class<*>, message: String? = null) = this shouldBeInstanceOf expected8fun <T> T.shouldNotBeInstanceOf(expected: Class<*>, message: String? = null) = this shouldNotBeInstanceOf expected9fun <T> T.shouldBeOneOf(vararg values: T, message: String? = null) = this shouldBeOneOf values10fun <T> T.shouldNotBeOneOf(vararg values: T, message: String? = null) = this shouldNotBeOneOf values11fun <T> T.shouldBeIn(vararg values: T, message: String? = null) = this shouldBeIn values12fun <T> T.shouldNotBeIn(vararg values: T, message: String? = null) = this shouldNotBeIn values13fun <T> T.shouldBeIn(values: Iterable<T>, message: String? = null) = this shouldBeIn values14fun <T> T.shouldNotBeIn(values: Iterable<T>, message: String? = null) = this shouldNotBeIn values15fun <T> T.shouldBeIn(values: Sequence<T>, message: String? = null) = this shouldBeIn values16fun <T> T.shouldNotBeIn(values: Sequence<T>, message: String? = null) = this shouldNotBeIn values17fun <T> T.shouldBeIn(values: Array<T>, message: String? = null) = this shouldBeIn values18fun <T> T.shouldNotBeIn(values: Array<T>, message: String? = null) = this shouldNotBeIn values

1fun <T> errorCollector(2f: ErrorCollector.() -> T3): T {4val collector = BasicErrorCollector()5val result = collector.f()6collector.throwCollectedErrors()7}8test("test1") {9errorCollector("test1") {10}11}12fun <T> errorCollector(13f: ErrorCollector.() -> T14): T {15val collector = BasicErrorCollector()16val result = collector.f()17collector.throwCollectedErrors()18}19test("test1") {20errorCollector("test1") {21}22}23fun <T> errorCollector(24f: ErrorCollector.() -> T25): T {26val collector = BasicErrorCollector()27val result = collector.f()28collector.throwCollectedErrors()29}30test("test1") {31errorCollector("test1") {32}33}34fun <T> errorCollector(35f: ErrorCollector.() -> T36): T {37val collector = BasicErrorCollector()38val result = collector.f()39collector.throwCollectedErrors()40}41test("test1") {42errorCollector("test1") {

1fun testMultipleConditions() {2    ErrorCollector.collectiveError {3    }4}5fun testMultipleConditions() {6    ErrorCollector.collectiveError {7    }8}9fun testMultipleConditions() {10    ErrorCollector.collectiveError {11    }12}13fun testMultipleConditions() {14    ErrorCollector.collectiveError {15    }16}17fun testMultipleConditions() {18    ErrorCollector.collectiveError {19    }20}21fun testMultipleConditions() {22    ErrorCollector.collectiveError {

1@Disabled("Disabled to avoid CI failure")2class ErrorCollectorTest : FunSpec({3  test("collect all errors and throw them at once") {4    val errorCollector = BasicErrorCollector()5    errorCollector.collectiveError("Error 1")6    errorCollector.collectiveError("Error 2")7    errorCollector.collectiveError("Error 3")8    errorCollector.assertAll()9  }10})11@Disabled("Disabled to avoid CI failure")12class ErrorCollectorTest : FunSpec({13  test("collect errors from multiple places and throw them at once") {14    val errorCollector = BasicErrorCollector()15    val errorCollector2 = BasicErrorCollector()16    errorCollector.collectiveError("Error 1")17    errorCollector2.collectiveError("Error 2")18    errorCollector.collectiveError("Error 3")19    errorCollector.assertAll()20    errorCollector2.assertAll()21  }22})23@Disabled("Disabled to avoid CI failure")24class AssertionsTest : FunSpec({25  test("basic assertions") {26    assertEquals(1, 1)27  }28})