How to use shouldThrowAssertionError method of com.sksamuel.kotest.matchers.doubles.DoubleMatchersTest class

...645      POSITIVE_INFINITY.shouldNotBeZero()646      NEGATIVE_INFINITY.shouldNotBeZero()647    }648  }649  private fun shouldThrowAssertionError(message: String, vararg expression: () -> Any?) {650    expression.forEach {651      val exception = shouldThrow<AssertionError>(it)652      exception.message shouldBe message653    }654  }655  private fun Double.shouldMatchBetween(a: Double, b: Double, tolerance: Double) {656    this.shouldBeBetween(a, b, tolerance)657    this shouldBe between(a, b, tolerance)658    this.shouldThrowExceptionOnNotBetween(a, b, tolerance)659  }660  private fun Double.shouldNotMatchBetween(a: Double, b: Double, tolerance: Double) {661    this.shouldNotBeBetween(a, b, tolerance)662    this shouldNotBe between(a, b, tolerance)663    this.shouldThrowExceptionOnBetween(a, b, tolerance)664  }665  private fun Double.shouldThrowExceptionOnBetween(a: Double, b: Double, tolerance: Double) {666    when {667      this < a -> this.shouldThrowMinimumExceptionOnBetween(a, b, tolerance)668      this > b -> this.shouldThrowMaximumExceptionOnBetween(a, b, tolerance)669      else     -> throw IllegalStateException()670    }671  }672  private fun Double.shouldThrowMinimumExceptionOnBetween(a: Double, b: Double, tolerance: Double) {673    val message = "$this should be bigger than $a"674    shouldThrowExceptionOnBetween(a, b, tolerance, message)675  }676  private fun Double.shouldThrowMaximumExceptionOnBetween(a: Double, b: Double, tolerance: Double) {677    val message = "$this should be smaller than $b"678    shouldThrowExceptionOnBetween(a, b, tolerance, message)679  }680  private fun Double.shouldThrowExceptionOnBetween(681    a: Double,682    b: Double,683    tolerance: Double,684    message: String = "$this should be smaller than $b and bigger than $a"685  ) {686    shouldThrowAssertionError(message,687                              { this.shouldBeBetween(a, b, tolerance) },688                              { this shouldBe between(a, b, tolerance) })689  }690  private fun Double.shouldThrowExceptionOnNotBetween(691    a: Double,692    b: Double,693    tolerance: Double,694    message: String = "$this should not be smaller than $b and should not be bigger than $a"695  ) {696    shouldThrowAssertionError(message,697                              { this.shouldNotBeBetween(a, b, tolerance) },698                              { this shouldNotBe between(a, b, tolerance) })699  }700  private infix fun Double.shouldMatchLessThan(x: Double) {701    this shouldBe lt(x)702    this shouldBeLessThan x703    this should beLessThan(x)704    this shouldThrowExceptionOnNotLessThan x705  }706  private infix fun Double.shouldThrowExceptionOnNotLessThan(x: Double) {707    shouldThrowAssertionError("$this should not be < $x",708                              { this shouldNotBe lt(x) },709                              { this shouldNotBeLessThan x },710                              { this shouldNot beLessThan(x) })711  }712  private infix fun Double.shouldNotMatchLessThan(x: Double) {713    this shouldNotBe lt(x)714    this shouldNotBeLessThan x715    this shouldNot beLessThan(x)716    this shouldThrowExceptionOnLessThan x717  }718  private infix fun Double.shouldThrowExceptionOnLessThan(x: Double) {719    shouldThrowAssertionError("$this should be < $x",720                              { this shouldBe lt(x) },721                              { this shouldBeLessThan x },722                              { this should beLessThan(x) }723    )724  }725  private fun Double.shouldMatchPositive() {726    this.shouldBePositive()727    this shouldBe positive()728    this.shouldThrowExceptionOnNotPositive()729  }730  private fun Double.shouldThrowExceptionOnNotPositive() {731    shouldThrowAssertionError("$this should not be > 0.0",732                              { this shouldNotBe positive() },733                              { this.shouldNotBePositive() }734    )735  }736  private fun Double.shouldNotMatchPositive() {737    this.shouldNotBePositive()738    this shouldNotBe positive()739    this.shouldThrowExceptionOnPositive()740  }741  private fun Double.shouldThrowExceptionOnPositive() {742    shouldThrowAssertionError("$this should be > 0.0",743                              { this shouldBe positive() },744                              { this.shouldBePositive() }745    )746  }747  private fun Double.shouldMatchNegative() {748    this.shouldBeNegative()749    this shouldBe negative()750    this.shouldThrowExceptionOnNotNegative()751  }752  private fun Double.shouldThrowExceptionOnNotNegative() {753    shouldThrowAssertionError("$this should not be < 0.0",754                              { this shouldNotBe negative() },755                              { this.shouldNotBeNegative() }756    )757  }758  private fun Double.shouldNotMatchNegative() {759    this.shouldNotBeNegative()760    this shouldNotBe negative()761    this.shouldThrowExceptionOnNegative()762  }763  private fun Double.shouldThrowExceptionOnNegative() {764    shouldThrowAssertionError("$this should be < 0.0",765                              { this shouldBe negative() },766                              { this.shouldBeNegative() }767    )768  }769  private infix fun Double.shouldMatchLessThanOrEqual(x: Double) {770    this should beLessThanOrEqualTo(x)771    this shouldBe lte(x)772    this shouldBeLessThanOrEqual x773    this shouldThrowExceptionOnNotLessThanOrEqual x774  }775  private infix fun Double.shouldThrowExceptionOnNotLessThanOrEqual(x: Double) {776    shouldThrowAssertionError("$this should not be <= $x",777                              { this shouldNot beLessThanOrEqualTo(x) },778                              { this shouldNotBe lte(x) },779                              { this shouldNotBeLessThanOrEqual x }780    )781  }782  private infix fun Double.shouldNotMatchLessThanOrEqual(x: Double) {783    this shouldNot beLessThanOrEqualTo(x)784    this shouldNotBe lte(x)785    this shouldNotBeLessThanOrEqual x786    this shouldThrowExceptionOnLessThanOrEqual x787  }788  private infix fun Double.shouldThrowExceptionOnLessThanOrEqual(x: Double) {789    shouldThrowAssertionError("$this should be <= $x",790                              { this should beLessThanOrEqualTo(x) },791                              { this shouldBe lte(x) },792                              { this shouldBeLessThanOrEqual x }793    )794  }795  private infix fun Double.shouldMatchGreaterThan(x: Double) {796    this should beGreaterThan(x)797    this shouldBe gt(x)798    this shouldBeGreaterThan x799    this shouldThrowExceptionOnNotGreaterThan x800  }801  private infix fun Double.shouldThrowExceptionOnNotGreaterThan(x: Double) {802    shouldThrowAssertionError("$this should not be > $x",803                              { this shouldNot beGreaterThan(x) },804                              { this shouldNotBeGreaterThan (x) },805                              { this shouldNotBe gt(x) })806  }807  private infix fun Double.shouldNotMatchGreaterThan(x: Double) {808    this shouldNot beGreaterThan(x)809    this shouldNotBe gt(x)810    this shouldNotBeGreaterThan x811    this shouldThrowExceptionOnGreaterThan (x)812  }813  private infix fun Double.shouldThrowExceptionOnGreaterThan(x: Double) {814    shouldThrowAssertionError("$this should be > $x",815                              { this should beGreaterThan(x) },816                              { this shouldBe gt(x) },817                              { this shouldBeGreaterThan x })818  }819  private infix fun Double.shouldMatchGreaterThanOrEqual(x: Double) {820    this should beGreaterThanOrEqualTo(x)821    this shouldBe gte(x)822    this shouldBeGreaterThanOrEqual x823    this shouldThrowExceptionOnNotGreaterThanOrEqual (x)824  }825  private infix fun Double.shouldThrowExceptionOnNotGreaterThanOrEqual(x: Double) {826    shouldThrowAssertionError("$this should not be >= $x",827                              { this shouldNot beGreaterThanOrEqualTo(x) },828                              { this shouldNotBe gte(x) },829                              { this shouldNotBeGreaterThanOrEqual x })830  }831  private infix fun Double.shouldNotMatchGreaterThanOrEqual(x: Double) {832    this shouldNot beGreaterThanOrEqualTo(x)833    this shouldNotBe gte(x)834    this shouldNotBeGreaterThanOrEqual x835    this shouldThrowExceptionOnGreaterThanOrEqual (x)836  }837  private infix fun Double.shouldThrowExceptionOnGreaterThanOrEqual(x: Double) {838    shouldThrowAssertionError("$this should be >= $x",839                              { this should beGreaterThanOrEqualTo(x) },840                              { this shouldBe gte(x) },841                              { this shouldBeGreaterThanOrEqual x })842  }843  private fun Double.shouldMatchNaN() {844    this should beNaN()845    this.shouldBeNaN()846    this.shouldThrowExceptionOnNotBeNaN()847  }848  private fun Double.shouldThrowExceptionOnNotBeNaN() {849    shouldThrowAssertionError("$this should not be NaN",850                              { this.shouldNotBeNaN() },851                              { this shouldNot beNaN() })852  }853  private fun Double.shouldNotMatchNaN() {854    this shouldNot beNaN()855    this.shouldNotBeNaN()856    this.shouldThrowExceptionOnBeNaN()857  }858  private fun Double.shouldThrowExceptionOnBeNaN() {859    shouldThrowAssertionError("$this should be NaN",860                              { this.shouldBeNaN() },861                              { this should beNaN() })862  }863  private fun Double.shouldMatchPositiveInfinity() {864    this should bePositiveInfinity()865    this.shouldBePositiveInfinity()866    this.shouldThrowExceptionOnNotBePositiveInfinity()867  }868  private fun Double.shouldThrowExceptionOnNotBePositiveInfinity() {869    shouldThrowAssertionError("$this should not be POSITIVE_INFINITY",870                              { this shouldNot bePositiveInfinity() },871                              { this.shouldNotBePositiveInfinity() })872  }873  private fun Double.shouldNotMatchPositiveInfinity() {874    this shouldNot bePositiveInfinity()875    this.shouldNotBePositiveInfinity()876    this.shouldThrowExceptionOnBePositiveInfinity()877  }878  private fun Double.shouldThrowExceptionOnBePositiveInfinity() {879    shouldThrowAssertionError("$this should be POSITIVE_INFINITY",880                              { this should bePositiveInfinity() },881                              { this.shouldBePositiveInfinity() })882  }883  private fun Double.shouldMatchNegativeInfinity() {884    this should beNegativeInfinity()885    this.shouldBeNegativeInfinity()886    this.shouldThrowExceptionOnNotBeNegativeInfinity()887  }888  private fun Double.shouldThrowExceptionOnNotBeNegativeInfinity() {889    shouldThrowAssertionError("$this should not be NEGATIVE_INFINITY",890            { this shouldNot beNegativeInfinity() },891            { this.shouldNotBeNegativeInfinity() })892  }893  private fun Double.shouldNotMatchNegativeInfinity() {894    this shouldNot beNegativeInfinity()895    this.shouldNotBeNegativeInfinity()896    this.shouldThrowExceptionOnBeNegativeInfinity()897  }898  private fun Double.shouldThrowExceptionOnBeNegativeInfinity() {899    shouldThrowAssertionError("$this should be NEGATIVE_INFINITY",900            { this should beNegativeInfinity() },901            { this.shouldBeNegativeInfinity() })902  }903}...

1shouldThrowAssertionError {2}3}4}5fun add(a: Int, b: Int) = a + b6fun `add should return sum of two numbers` () {7}8}