How to use Positive class of io.kotest.matchers.doubles package

Best Kotest code snippet using io.kotest.matchers.doubles.Positive

DoubleMatchersTest.kt

Source:DoubleMatchersTest.kt Github

copy

Full Screen

...7import io.kotest.matchers.doubles.beLessThan8import io.kotest.matchers.doubles.beLessThanOrEqualTo9import io.kotest.matchers.doubles.beNaN10import io.kotest.matchers.doubles.beNegativeInfinity11import io.kotest.matchers.doubles.bePositiveInfinity12import io.kotest.matchers.doubles.between13import io.kotest.matchers.doubles.gt14import io.kotest.matchers.doubles.gte15import io.kotest.matchers.doubles.lt16import io.kotest.matchers.doubles.lte17import io.kotest.matchers.doubles.negative18import io.kotest.matchers.doubles.positive19import io.kotest.matchers.doubles.shouldBeBetween20import io.kotest.matchers.doubles.shouldBeGreaterThan21import io.kotest.matchers.doubles.shouldBeGreaterThanOrEqual22import io.kotest.matchers.doubles.shouldBeLessThan23import io.kotest.matchers.doubles.shouldBeLessThanOrEqual24import io.kotest.matchers.doubles.shouldBeMultipleOf25import io.kotest.matchers.doubles.shouldBeNaN26import io.kotest.matchers.doubles.shouldBeNegative27import io.kotest.matchers.doubles.shouldBeNegativeInfinity28import io.kotest.matchers.doubles.shouldBePositive29import io.kotest.matchers.doubles.shouldBePositiveInfinity30import io.kotest.matchers.doubles.shouldBeZero31import io.kotest.matchers.doubles.shouldNotBeBetween32import io.kotest.matchers.doubles.shouldNotBeGreaterThan33import io.kotest.matchers.doubles.shouldNotBeGreaterThanOrEqual34import io.kotest.matchers.doubles.shouldNotBeLessThan35import io.kotest.matchers.doubles.shouldNotBeLessThanOrEqual36import io.kotest.matchers.doubles.shouldNotBeNaN37import io.kotest.matchers.doubles.shouldNotBeNegative38import io.kotest.matchers.doubles.shouldNotBeNegativeInfinity39import io.kotest.matchers.doubles.shouldNotBePositive40import io.kotest.matchers.doubles.shouldNotBePositiveInfinity41import io.kotest.matchers.doubles.shouldNotBeZero42import io.kotest.matchers.should43import io.kotest.matchers.shouldBe44import io.kotest.matchers.shouldNot45import io.kotest.matchers.shouldNotBe46import io.kotest.property.arbitrary.filterNot47import io.kotest.property.checkAll48import kotlin.Double.Companion.MAX_VALUE49import kotlin.Double.Companion.MIN_VALUE50import kotlin.Double.Companion.NEGATIVE_INFINITY51import kotlin.Double.Companion.NaN52import kotlin.Double.Companion.POSITIVE_INFINITY53import kotlin.math.absoluteValue54class DoubleMatchersTest : FreeSpec() {55 init {56 "Between matcher" - {57 "Every numeric double that is not Double.MAX_VALUE" - {58 "Should match between" - {59 "When it's equal to the first number of the range" - {60 "With tolerance" {61 checkAll(100, nonMinNorMaxValueDoubles) {62 it.shouldMatchBetween(it, it.slightlyGreater(), it.toleranceValue())63 }64 }65 "Without tolerance" {66 checkAll(100, nonMinNorMaxValueDoubles) {67 it.shouldMatchBetween(it, it.slightlyGreater(), 0.0)68 }69 }70 }71 "When it's between the first number of the range and the last one" - {72 "With tolerance" {73 checkAll(100, nonMinNorMaxValueDoubles) {74 it.shouldMatchBetween(it.slightlySmaller(), it.slightlyGreater(), it.toleranceValue())75 }76 }77 "Without tolerance" {78 checkAll(100, nonMinNorMaxValueDoubles) {79 it.shouldMatchBetween(it.slightlySmaller(), it.slightlyGreater(), 0.0)80 }81 }82 }83 "When it's equal to the last number of the range" - {84 "With tolerance" {85 checkAll(100, nonMinNorMaxValueDoubles) {86 it.shouldMatchBetween(it.slightlySmaller(), it, it.toleranceValue())87 }88 }89 "Without tolerance" {90 checkAll(100, nonMinNorMaxValueDoubles) {91 it.shouldMatchBetween(it.slightlySmaller(), it, 0.0)92 }93 }94 }95 }96 "Should not match between" - {97 "When it's smaller than the first number of the range" - {98 "With tolerance" {99 checkAll(100, nonMinNorMaxValueDoubles) {100 it.shouldNotMatchBetween(it.slightlyGreater(), it.muchGreater(), it.toleranceValue())101 }102 }103 "Without tolerance" {104 checkAll(100, nonMinNorMaxValueDoubles) {105 it.shouldNotMatchBetween(it.slightlyGreater(), it.muchGreater(), 0.0)106 }107 }108 }109 "When it's bigger than the last number of the range" - {110 "With tolerance" {111 checkAll(100, nonMinNorMaxValueDoubles) {112 it.shouldNotMatchBetween(it.muchSmaller(), it.slightlySmaller(), it.toleranceValue())113 }114 }115 "Without tolerance" {116 checkAll(100, nonMinNorMaxValueDoubles) {117 it.shouldNotMatchBetween(it.muchSmaller(), it.slightlySmaller(), 0.0)118 }119 }120 }121 }122 }123 }124 "Less than matcher" - {125 "Every numeric double" - {126 "Should be less than" - {127 "Numbers bigger than itself" {128 checkAll(100, nonMinNorMaxValueDoubles) {129 it shouldMatchLessThan it.slightlyGreater()130 it shouldMatchLessThan it.muchGreater()131 }132 }133 "Infinity" {134 checkAll(100, nonMinNorMaxValueDoubles) {135 it shouldMatchLessThan POSITIVE_INFINITY136 }137 }138 }139 "Should not be less than" - {140 "Itself" {141 checkAll(100, nonMinNorMaxValueDoubles) {142 it shouldNotMatchLessThan it143 }144 }145 "Numbers smaller than itself" {146 checkAll(100, nonMinNorMaxValueDoubles) {147 it shouldNotMatchLessThan it.slightlySmaller()148 it shouldNotMatchLessThan it.muchSmaller()149 }150 }151 "Negative Infinity" {152 checkAll(100, nonMinNorMaxValueDoubles) {153 it shouldNotMatchLessThan it154 }155 }156 "NaN" {157 checkAll(100, nonMinNorMaxValueDoubles) {158 it shouldNotMatchLessThan NaN159 }160 }161 }162 }163 "The non-numeric double" - {164 "NaN" - {165 "Should not be less than" - {166 "Any numeric double" {167 checkAll(100, nonMinNorMaxValueDoubles) {168 NaN shouldNotMatchLessThan it169 }170 }171 "Any non-numeric double" {172 nonNumericDoubles.forEach {173 NaN shouldNotMatchLessThan it174 }175 }176 }177 }178 "Positive Infinity" - {179 "Should not be less than" - {180 "Any numeric double" {181 checkAll(100, nonMinNorMaxValueDoubles) {182 POSITIVE_INFINITY shouldNotMatchLessThan it183 }184 }185 "Any non-numeric double" {186 nonNumericDoubles.forEach {187 POSITIVE_INFINITY shouldNotMatchLessThan it188 }189 }190 }191 }192 "Negative Infinity" - {193 "Should be less than" - {194 "Any numeric double" {195 checkAll(100, nonMinNorMaxValueDoubles) {196 NEGATIVE_INFINITY shouldMatchLessThan it197 }198 }199 "Positive Infinity" {200 NEGATIVE_INFINITY shouldMatchLessThan POSITIVE_INFINITY201 }202 }203 "Should not be less than" - {204 "Itself" {205 NEGATIVE_INFINITY shouldNotMatchLessThan NEGATIVE_INFINITY206 }207 "NaN" {208 NEGATIVE_INFINITY shouldNotMatchLessThan NaN209 }210 }211 }212 }213 }214 "Positive matcher" - {215 "Zero" - {216 "Should not be positive" {217 0.0.shouldNotMatchPositive()218 }219 }220 "Every positive number" - {221 "Should be positive" {222 checkAll(100, numericDoubles.filterNot { it == 0.0 }) {223 it.absoluteValue.shouldMatchPositive()224 }225 }226 }227 "Every non-positive number" - {228 "Should not be positive" {229 checkAll(100, numericDoubles) {230 (-it.absoluteValue).shouldNotMatchPositive()231 }232 }233 }234 "The non-numeric double" - {235 "Positive Infinity" - {236 "Should be positive" {237 POSITIVE_INFINITY.shouldMatchPositive()238 }239 }240 "Negative Infinity" - {241 "Should not be positive" {242 NEGATIVE_INFINITY.shouldNotMatchPositive()243 }244 }245 "NaN" - {246 "Should not be positive" {247 NaN.shouldNotMatchPositive()248 }249 }250 }251 }252 "Negative matcher" - {253 "Zero" - {254 "Should not be negative" {255 0.0.shouldNotMatchNegative()256 }257 }258 "Every negative number" - {259 "Should be negative" {260 checkAll(100, numericDoubles.filterNot { it == 0.0 }) {261 (-it.absoluteValue).shouldMatchNegative()262 }263 }264 }265 "Every non-negative number" - {266 "Should not be negative" {267 checkAll(100, numericDoubles) {268 it.absoluteValue.shouldNotMatchNegative()269 }270 }271 }272 "The non-numeric double" - {273 "Positive Infinity" - {274 "Should not be negative" {275 POSITIVE_INFINITY.shouldNotMatchNegative()276 }277 }278 "Negative Infinity" - {279 "Should be negative" {280 NEGATIVE_INFINITY.shouldMatchNegative()281 }282 }283 "NaN" - {284 "Should not be negative" {285 NaN.shouldNotMatchNegative()286 }287 }288 }289 }290 "MultipleOf matcher" - {291 "Matches a simple multiple" {292 300.0 shouldBeMultipleOf 1.0293 }294 "Fails due to precision problems" {295 shouldFail {296 3.6e300 shouldBeMultipleOf 1.2297 }298 }299 }300 "Less than or equal matcher" - {301 "Every numeric double" - {302 "Should be less than or equal" - {303 "Itself" {304 checkAll(100, nonMinNorMaxValueDoubles) {305 it shouldMatchLessThanOrEqual it306 }307 }308 "Numbers bigger than itself" {309 checkAll(100, nonMinNorMaxValueDoubles) {310 it shouldMatchLessThanOrEqual it.muchGreater()311 it shouldMatchLessThanOrEqual it.slightlyGreater()312 }313 }314 "Positive Infinity" {315 checkAll(100, nonMinNorMaxValueDoubles) {316 it shouldMatchLessThanOrEqual POSITIVE_INFINITY317 }318 }319 }320 "Should not be less than or equal" - {321 "Any number smaller than itself" {322 checkAll(100, nonMinNorMaxValueDoubles) {323 it shouldNotMatchLessThanOrEqual it.slightlySmaller()324 it shouldNotMatchLessThanOrEqual it.muchSmaller()325 }326 }327 "Negative Infinity" {328 checkAll(100, nonMinNorMaxValueDoubles) {329 it shouldNotMatchLessThanOrEqual NEGATIVE_INFINITY330 }331 }332 "NaN" {333 checkAll(100, nonMinNorMaxValueDoubles) {334 it shouldNotMatchLessThanOrEqual NaN335 }336 }337 }338 }339 "The non-numeric double" - {340 "NaN" {341 "Should not be less than or equal" - {342 "Any numeric double" {343 checkAll(100, nonMinNorMaxValueDoubles) {344 NaN shouldNotMatchLessThanOrEqual it345 }346 }347 "Positive Infinity" {348 NaN shouldNotMatchLessThanOrEqual POSITIVE_INFINITY349 }350 "Negative Infinity" {351 NaN shouldNotMatchLessThanOrEqual NEGATIVE_INFINITY352 }353 "Itself" {354 NaN shouldNotMatchLessThanOrEqual NaN355 }356 }357 }358 "Positive Infinity" - {359 "Should be less than or equal" - {360 "Positive Infinity" {361 POSITIVE_INFINITY shouldMatchLessThanOrEqual POSITIVE_INFINITY362 }363 }364 "Should not be less than or equal" - {365 "Any numeric double" {366 checkAll(100, nonMinNorMaxValueDoubles) {367 POSITIVE_INFINITY shouldNotMatchLessThanOrEqual it368 }369 }370 "Negative Infinity" {371 POSITIVE_INFINITY shouldNotMatchLessThanOrEqual NEGATIVE_INFINITY372 }373 "NaN" {374 POSITIVE_INFINITY shouldNotMatchLessThanOrEqual NaN375 }376 }377 }378 "Negative Infinity" - {379 "Should be less than or equal" - {380 "Any numeric double" {381 checkAll(100, nonMinNorMaxValueDoubles) {382 NEGATIVE_INFINITY shouldMatchLessThanOrEqual it383 }384 }385 "Positive Infinity" {386 NEGATIVE_INFINITY shouldMatchLessThanOrEqual POSITIVE_INFINITY387 }388 "Itself" {389 NEGATIVE_INFINITY shouldMatchLessThanOrEqual NEGATIVE_INFINITY390 }391 }392 "Should not be less than or equal" - {393 "NaN" {394 NEGATIVE_INFINITY shouldNotMatchLessThanOrEqual NaN395 }396 }397 }398 }399 }400 "Greater than matcher" - {401 "Every numeric double" - {402 "Should be greater than" - {403 "Numbers smaller than itself" {404 checkAll(100, nonMinNorMaxValueDoubles) {405 it shouldMatchGreaterThan it.slightlySmaller()406 it shouldMatchGreaterThan it.muchSmaller()407 }408 }409 "Negative infinity" {410 checkAll(100, nonMinNorMaxValueDoubles) {411 it shouldMatchGreaterThan NEGATIVE_INFINITY412 }413 }414 }415 "Should not be greater than" - {416 "Itself" {417 checkAll(100, nonMinNorMaxValueDoubles) {418 it shouldNotMatchGreaterThan it419 }420 }421 "Numbers greater than itself" {422 checkAll(100, nonMinNorMaxValueDoubles) {423 it shouldNotMatchGreaterThan it.slightlyGreater()424 it shouldNotMatchGreaterThan it.muchGreater()425 }426 }427 "NaN" {428 checkAll(100, nonMinNorMaxValueDoubles) {429 it shouldNotMatchGreaterThan NaN430 }431 }432 "Positive Infinity" {433 checkAll(100, nonMinNorMaxValueDoubles) {434 it shouldNotMatchGreaterThan POSITIVE_INFINITY435 }436 }437 }438 }439 "The non-numeric double" - {440 "NaN" - {441 "Should not be greater than" - {442 "Itself" {443 NaN shouldNotMatchGreaterThan NaN444 }445 "Any numeric double" {446 checkAll(100, numericDoubles) {447 NaN shouldNotMatchGreaterThan it448 }449 }450 "Positive Infinity" {451 NaN shouldNotMatchGreaterThan POSITIVE_INFINITY452 }453 "Negative Infinity" {454 NaN shouldNotMatchGreaterThan NEGATIVE_INFINITY455 }456 }457 }458 }459 }460 "Greater than or equal matcher" - {461 "Every numeric double" - {462 "Should be greater than or equal to" - {463 "Itself" {464 checkAll(100, nonMinNorMaxValueDoubles) {465 it shouldMatchGreaterThanOrEqual it466 }467 }468 "Numbers smaller than itself" {469 checkAll(100, nonMinNorMaxValueDoubles) {470 it shouldMatchGreaterThanOrEqual it.slightlySmaller()471 it shouldMatchGreaterThanOrEqual it.muchSmaller()472 }473 }474 "Negative Infinity" {475 checkAll(100, nonMinNorMaxValueDoubles) {476 it shouldMatchGreaterThanOrEqual NEGATIVE_INFINITY477 }478 }479 }480 "Should not be greater than or equal to" - {481 "Numbers bigger than itself" {482 checkAll(100, nonMinNorMaxValueDoubles) {483 it shouldNotMatchGreaterThanOrEqual it.slightlyGreater()484 it shouldNotMatchGreaterThanOrEqual it.muchGreater()485 }486 }487 "Positive Infinity" {488 checkAll(100, nonMinNorMaxValueDoubles) {489 it shouldNotMatchGreaterThanOrEqual POSITIVE_INFINITY490 }491 }492 "NaN" {493 checkAll(100, nonMinNorMaxValueDoubles) {494 it shouldNotMatchGreaterThanOrEqual NaN495 }496 }497 }498 }499 "The non-numeric double" - {500 "NaN" - {501 "Should not be greater than or equal to" - {502 "Itself" {503 NaN shouldNotMatchGreaterThanOrEqual NaN504 }505 "Any numeric double" {506 checkAll(100, numericDoubles) {507 NaN shouldNotMatchGreaterThanOrEqual it508 }509 }510 "Positive Infinity" {511 NaN shouldNotMatchGreaterThanOrEqual POSITIVE_INFINITY512 }513 "Negative Infinity" {514 NaN shouldNotMatchGreaterThanOrEqual NEGATIVE_INFINITY515 }516 }517 }518 "Positive Infinity" - {519 "Should be greater than or equal to" - {520 "Itself" {521 POSITIVE_INFINITY shouldMatchGreaterThanOrEqual POSITIVE_INFINITY522 }523 "Negative Infinity" {524 POSITIVE_INFINITY shouldMatchGreaterThanOrEqual NEGATIVE_INFINITY525 }526 "Any numeric double" {527 checkAll(100, numericDoubles) {528 POSITIVE_INFINITY shouldMatchGreaterThanOrEqual it529 }530 }531 }532 "Should not be greater than or equal to" - {533 "NaN" {534 POSITIVE_INFINITY shouldNotMatchGreaterThanOrEqual NaN535 }536 }537 }538 "Negative Infinity" - {539 "Should be greater than or equal to" - {540 "Itself" {541 NEGATIVE_INFINITY shouldMatchGreaterThanOrEqual NEGATIVE_INFINITY542 }543 }544 "Should not be greater than or equal to" - {545 "Any numeric double" {546 checkAll(100, numericDoubles) {547 NEGATIVE_INFINITY shouldNotMatchGreaterThanOrEqual it548 }549 }550 "Positive Infinity" {551 NEGATIVE_INFINITY shouldNotMatchGreaterThanOrEqual POSITIVE_INFINITY552 }553 "NaN" {554 NEGATIVE_INFINITY shouldNotMatchGreaterThanOrEqual NaN555 }556 }557 }558 }559 }560 "NaN matcher" - {561 "Every numeric double" - {562 "Should not be NaN" {563 checkAll(100, numericDoubles) {564 it.shouldNotMatchNaN()565 }566 }567 }568 "The non-numeric double" - {569 "NaN" - {570 "Should match NaN" {571 NaN.shouldMatchNaN()572 }573 }574 "Positive Infinity" - {575 "Should not match NaN" {576 POSITIVE_INFINITY.shouldNotMatchNaN()577 }578 }579 "Negative Infinity" - {580 "Should not match NaN" {581 NEGATIVE_INFINITY.shouldNotMatchNaN()582 }583 }584 }585 }586 "Positive Infinity matcher" - {587 "Any numeric double" - {588 "Should not match positive infinity" {589 checkAll(100, numericDoubles) {590 it.shouldNotMatchPositiveInfinity()591 }592 }593 }594 "The non-numeric double" - {595 "Positive Infinity" - {596 "Should match positive infinity" {597 POSITIVE_INFINITY.shouldMatchPositiveInfinity()598 }599 }600 "Negative Infinity" - {601 "Should not match positive infinity" {602 NEGATIVE_INFINITY.shouldNotMatchPositiveInfinity()603 }604 }605 "NaN" - {606 "Should not match positive infinity" {607 NaN.shouldNotMatchPositiveInfinity()608 }609 }610 }611 }612 "Negative Infinity matcher" - {613 "Any numeric double" - {614 "Should not match negative infinity" {615 checkAll(100, numericDoubles) {616 it.shouldNotMatchNegativeInfinity()617 }618 }619 }620 "The non-numeric double" - {621 "Negative Infinity" - {622 "Should match negative infinity" {623 NEGATIVE_INFINITY.shouldMatchNegativeInfinity()624 }625 }626 "Positive Infinity" - {627 "Should not match negative infinity" {628 POSITIVE_INFINITY.shouldNotMatchNegativeInfinity()629 }630 }631 "NaN" - {632 "Should not match negative infinity" {633 NaN.shouldNotMatchNegativeInfinity()634 }635 }636 }637 }638 "shouldBeZero" {639 (0.0).shouldBeZero()640 (-0.1).shouldNotBeZero()641 (0.1).shouldNotBeZero()642 MIN_VALUE.shouldNotBeZero()643 MAX_VALUE.shouldNotBeZero()644 NaN.shouldNotBeZero()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()...

Full Screen

Full Screen

matchers.kt

Source:matchers.kt Github

copy

Full Screen

...51import io.kotest.matchers.ints.shouldBeInRange52import io.kotest.matchers.ints.shouldBeLessThan53import io.kotest.matchers.ints.shouldBeLessThanOrEqual54import io.kotest.matchers.ints.shouldBeOdd55import io.kotest.matchers.ints.shouldBePositive56import io.kotest.matchers.ints.shouldBeZero57import io.kotest.matchers.iterator.shouldBeEmpty58import io.kotest.matchers.iterator.shouldHaveNext59import io.kotest.matchers.maps.shouldBeEmpty60import io.kotest.matchers.maps.shouldContain61import io.kotest.matchers.maps.shouldContainAll62import io.kotest.matchers.maps.shouldContainExactly63import io.kotest.matchers.maps.shouldContainKey64import io.kotest.matchers.nulls.shouldBeNull65import io.kotest.matchers.nulls.shouldNotBeNull66import io.kotest.matchers.shouldBe67import io.kotest.matchers.shouldNot68import io.kotest.matchers.shouldNotBe69import io.kotest.matchers.string.beEmpty70import io.kotest.matchers.string.shouldBeBlank71import io.kotest.matchers.string.shouldBeEmpty72import io.kotest.matchers.string.shouldBeEqualIgnoringCase73import io.kotest.matchers.string.shouldBeInteger74import io.kotest.matchers.string.shouldBeLowerCase75import io.kotest.matchers.string.shouldBeUpperCase76import io.kotest.matchers.string.shouldContain77import io.kotest.matchers.string.shouldContainADigit78import io.kotest.matchers.string.shouldContainIgnoringCase79import io.kotest.matchers.string.shouldContainOnlyDigits80import io.kotest.matchers.string.shouldContainOnlyOnce81import io.kotest.matchers.string.shouldEndWith82import io.kotest.matchers.string.shouldHaveLength83import io.kotest.matchers.string.shouldHaveLineCount84import io.kotest.matchers.string.shouldHaveMaxLength85import io.kotest.matchers.string.shouldHaveMinLength86import io.kotest.matchers.string.shouldHaveSameLengthAs87import io.kotest.matchers.string.shouldMatch88import io.kotest.matchers.string.shouldNotBeEmpty89import io.kotest.matchers.string.shouldStartWith90import io.kotest.matchers.throwable.shouldHaveCause91import io.kotest.matchers.throwable.shouldHaveCauseInstanceOf92import io.kotest.matchers.throwable.shouldHaveCauseOfType93import io.kotest.matchers.throwable.shouldHaveMessage94import io.kotest.matchers.types.shouldBeInstanceOf95import io.kotest.matchers.types.shouldBeSameInstanceAs96import io.kotest.matchers.types.shouldBeTypeOf97import io.kotest.matchers.uri.shouldHaveHost98import io.kotest.matchers.uri.shouldHavePort99import io.kotest.matchers.uri.shouldHaveScheme100import java.io.File101import java.net.URI102import java.time.LocalDate103import java.time.LocalTime104// https://kotest.io/docs/assertions/core-matchers.html105class MatchersTest : DescribeSpec({106 describe("general") {107 it("basics") {108 (1 == 1).shouldBeTrue()109 (2 + 2) shouldBe 4110 val foo: Any = "foobar"111 foo.shouldBeTypeOf<String>() shouldContain "fo"112 "".shouldBeEmpty()113 "x".shouldNot(beEmpty()) // manually negate114 "x".shouldNotBeEmpty() // reusable115 URI("https://tba") shouldHaveHost "tba"116 URI("https://tba:81") shouldHavePort 81117 URI("https://tba") shouldHaveScheme "https"118 File("/").apply {119 shouldExist()120 shouldBeADirectory()121 shouldBeAbsolute()122 shouldNotBeEmpty()123 }124 // executable, hidden, readable, smaller, writeable, containFile, extension, path, ...125 LocalDate.now().shouldBeToday()126 // before/after, within, same, between, have year/month/day/hour/...127 LocalTime.now().shouldHaveSameHoursAs(LocalTime.now())128 // before/after/between, sameMinute/Seconds/Nanos129 }130 it("numbers") {131 1 shouldBeLessThan 2132 1 shouldBeLessThanOrEqual 1 // Int-based; returns this133 1 shouldBeLessThanOrEqualTo 1 // Comparble-based; void134 1 shouldBeEqualComparingTo 1 // Comparable-based135 1.shouldBeBetween(0, 2)136 1 shouldBeInRange 0..2137 0.shouldBeZero()138 1.shouldBePositive()139 1.shouldBeOdd()140 (1.2).shouldBe(1.20001.plusOrMinus(Percentage(20.0)))141 (1.2).shouldNotBeNaN()142 }143 it("strings") {144 // generic: "abc" shouldBe "abc"145 "aBc" shouldBeEqualIgnoringCase "abc"146 "".shouldBeEmpty()147 " ".shouldBeBlank() // empty or whitespace148 "abc" shouldContain ("b")149 "aBc" shouldContainIgnoringCase "bc"150 "x-a-x" shouldContain """\-[a-z]\-""".toRegex()151 "-a-" shouldMatch """\-[a-z]\-""".toRegex()152 "abc" shouldStartWith ("a")...

Full Screen

Full Screen

DoubleExactlyTest.kt

Source:DoubleExactlyTest.kt Github

copy

Full Screen

...51 Double.Companion.NaN shouldNotMatchExactly Double.Companion.NEGATIVE_INFINITY52 }53 }54 }55 "Positive Infinity" - {56 "Should be exactly" - {57 "Itself" {58 Double.Companion.POSITIVE_INFINITY shouldExactlyMatch Double.Companion.POSITIVE_INFINITY59 }60 }61 "Should not be exactly" - {62 "Any numeric double" {63 checkAll(100, numericDoubles) {64 Double.POSITIVE_INFINITY shouldNotMatchExactly it65 }66 }67 "Any other non-numeric double" {68 Double.Companion.POSITIVE_INFINITY shouldNotMatchExactly Double.Companion.NEGATIVE_INFINITY69 Double.Companion.POSITIVE_INFINITY shouldNotMatchExactly Double.Companion.NaN...

Full Screen

Full Screen

DoubleNumberTests.kt

Source:DoubleNumberTests.kt Github

copy

Full Screen

2import io.kotest.core.spec.style.StringSpec3import io.kotest.matchers.booleans.shouldBeFalse4import io.kotest.matchers.booleans.shouldBeTrue5import io.kotest.matchers.doubles.plusOrMinus6import io.kotest.matchers.doubles.shouldBePositiveInfinity7import io.kotest.matchers.shouldBe8class DoubleNumberTests : StringSpec({9 "3 * 9.1 = 18.3" {10 (DoubleNumber(3.0) * DoubleNumber(9.1)).value shouldBe (27.3 plusOrMinus 1e-10)11 }12 "3 / 2 = 1.5" {13 (DoubleNumber(3.0) / DoubleNumber(2.0)) shouldBe DoubleNumber(1.5)14 }15 "3 / 0 = +INF" {16 (DoubleNumber(3.0) / DoubleNumber(0.0)).value.shouldBePositiveInfinity()17 }18 "обратное к 5 = 0.2" {19 DoubleNumber(5.0).inverse() shouldBe DoubleNumber(0.2)20 }21 "обратное к 0 = +INF" {22 DoubleNumber(0.0).inverse().value.shouldBePositiveInfinity()23 }24 "5 положительно" {25 DoubleNumber(5.0).isPositive.shouldBeTrue()26 }27 "1e-30 положительно" {28 DoubleNumber(1e-30).isPositive.shouldBeTrue()29 }30 "0 не положительно" {31 DoubleNumber(0.0).isPositive.shouldBeFalse()32 }33 "Double.MIN_VALUE положительно" {34 DoubleNumber(Double.MIN_VALUE).isPositive.shouldBeTrue()35 }36 "-3 не положительно" {37 DoubleNumber(-3.0).isPositive.shouldBeFalse()38 }39 "13.565 в строку и в double даёт то же самое число" {40 val x = 13.56541 DoubleNumber(x).toString().toDouble() shouldBe x42 }43 // Kind of acceptance tests below44 "1/3 * 1000 в строку отдаёт 34 значащие цифры и округляет вниз" {45 val x = DoubleNumber(1.0).divideBy(DoubleNumber(3.0)).multiplyBy(DoubleNumber(1000.0))46 x.toString() shouldBe "333.3333333333333143855270463973284"47 }48 "2/3 * 1000 в строку отдаёт 34 значащие цифры и округляет вверх" {49 val x = DoubleNumber(2.0).divideBy(DoubleNumber(3.0)).multiplyBy(DoubleNumber(1000.0))50 x.toString() shouldBe "666.6666666666666287710540927946568"51 }...

Full Screen

Full Screen

BLEDistanceUnscentedKalmanFilterTest.kt

Source:BLEDistanceUnscentedKalmanFilterTest.kt Github

copy

Full Screen

...7import io.kotest.property.checkAll8import uk.nhs.riskscore.internal.kotest.bleDistanceUnscentedKalmanFilter9import uk.nhs.riskscore.internal.kotest.nonEmptyList10import uk.nhs.riskscore.internal.kotest.smallNumericDoubles11import uk.nhs.riskscore.internal.kotest.smallPositiveDoubles12internal class BLEDistanceUnscentedKalmanFilterTest : StringSpec({13 "transition function is non-negative" {14 checkAll(15 smallNumericDoubles,16 smallNumericDoubles,17 bleDistanceUnscentedKalmanFilter) { state, noise, filter ->18 val result = filter.transitionFunction(state, noise)19 result shouldBeGreaterThanOrEqual 0.020 }21 }22 "smooth function returns the same number of elements as the input" {23 checkAll(24 100,25 bleDistanceUnscentedKalmanFilter,26 smallPositiveDoubles.orNull(0.1).nonEmptyList(2)27 ) { filter, attenutations ->28 filter.smooth(attenutations).size shouldBeExactly attenutations.size29 }30 }31 "smooth function returns finite results" {32 checkAll(33 100,34 bleDistanceUnscentedKalmanFilter,35 smallPositiveDoubles.orNull(0.1).nonEmptyList(2)36 ) { filter, attenutations ->37 filter.smooth(attenutations).all { (mean, covariance) ->38 mean.isFinite() && covariance.isFinite()39 }.shouldBeTrue()40 }41 }42})...

Full Screen

Full Screen

QuadraticRiskScoreTest.kt

Source:QuadraticRiskScoreTest.kt Github

copy

Full Screen

2import io.kotest.core.spec.style.StringSpec3import io.kotest.matchers.doubles.shouldBeLessThanOrEqual4import io.kotest.property.checkAll5import uk.nhs.riskscore.internal.kotest.nonEmptyList6import uk.nhs.riskscore.internal.kotest.smallPositiveDoubles7internal class QuadraticRiskScoreTest : StringSpec({8 "risk score is bounded by sum of durations" {9 checkAll(10 smallPositiveDoubles,11 smallPositiveDoubles.nonEmptyList(),12 smallPositiveDoubles.nonEmptyList()13 ) { minDistance, durations, distances ->14 val score = QuadraticRiskScore(minDistance).calculate(15 durations = durations,16 distances = distances,17 shouldNormalize = false18 )19 score shouldBeLessThanOrEqual durations.sum()20 }21 }22 "normalized risk score is bounded above by 1" {23 checkAll(24 smallPositiveDoubles,25 smallPositiveDoubles.nonEmptyList(),26 smallPositiveDoubles.nonEmptyList()27 ) { minDistance, durations, distances ->28 val score = QuadraticRiskScore(minDistance).calculate(29 durations = durations,30 distances = distances,31 shouldNormalize = true32 )33 score shouldBeLessThanOrEqual 1.034 }35 }36})

Full Screen

Full Screen

BmiEnglishUnitsTest.kt

Source:BmiEnglishUnitsTest.kt Github

copy

Full Screen

1package pl.mprzymus.bmi.bmi_count2import io.kotest.assertions.throwables.shouldThrow3import io.kotest.core.spec.style.FunSpec4import io.kotest.matchers.doubles.plusOrMinus5import io.kotest.matchers.shouldBe6class BmiEnglishUnitsTest : FunSpec({7 val tested = BmiEnglishUnits()8 test("should count BMI properly with good input") {9 tested.countBmi(85.0, 200.0) shouldBe (19.55 plusOrMinus 0.1)10 }11 test("BMI should be 0 when weight is 0") {12 tested.countBmi(180.0, 0.0) shouldBe 0.013 }14 test("should return infinity when height is 0") {15 tested.countBmi(0.0, 70.0) shouldBe Double.POSITIVE_INFINITY16 }17 test("should throw when get negative height") {18 shouldThrow <IllegalArgumentException> { tested.countBmi(-1.0, 10.0) }19 }20})...

Full Screen

Full Screen

BmiMetricTest.kt

Source:BmiMetricTest.kt Github

copy

Full Screen

1package pl.mprzymus.bmi.bmi_count2import io.kotest.assertions.throwables.shouldThrow3import io.kotest.core.spec.style.FunSpec4import io.kotest.matchers.doubles.plusOrMinus5import io.kotest.matchers.shouldBe6class BmiMetricTest : FunSpec({7 val tested = BmiMetric()8 test("should count BMI properly with good input") {9 tested.countBmi(180.0, 70.0) shouldBe (21.55 plusOrMinus 0.1)10 }11 test("BMI should be 0 when weight is 0") {12 tested.countBmi(180.0, 0.0) shouldBe 0.013 }14 test("should return infinity when height is 0") {15 tested.countBmi(0.0, 70.0) shouldBe Double.POSITIVE_INFINITY16 }17 test("should throw when get negative height") {18 shouldThrow <IllegalArgumentException> { tested.countBmi(-1.0, 10.0) }19 }20})...

Full Screen

Full Screen

Positive

Using AI Code Generation

copy

Full Screen

1assertThat(1.0).isPositive()2assertThat(1.0).isNegative()3assertThat(0.0).isZero()4assertThat(Double.NaN).isNaN()5assertThat(Double.POSITIVE_INFINITY).isInfinite()6assertThat(Double.POSITIVE_INFINITY).isPositiveInfinity()7assertThat(Double.NEGATIVE_INFINITY).isNegativeInfinity()8assertThat(1.0).isGreaterThan(0.5)9assertThat(1.0).isLessThan(2.0)10assertThat(1.0).isBetween(0.5, 2.0)11assertThat(1.0).isBetween(0.5, 1.0)12assertThat(1.0).isBetween(1.0, 2.0)13assertThat(1.0).isBetween(0.5, 2.0, true, true)14assertThat(1.0).isBetween(0.5, 1.0, true, true)15assertThat(1.0).isBetween(1.0, 2.0, true, true)16assertThat(1.0).isBetween(0.5, 2.0, false, false)17assertThat(1.0).isBetween(0.5, 1.0, false, false)18assertThat(1.0).isBetween(1.0, 2.0, false, false)19assertThat(1.0).isBetween(0.5, 2.0, false, true)20assertThat(1.0).isBetween(0.5, 1.0, false, true)21assertThat(1.0).isBetween(1.0, 2.0, false, true)22assertThat(1.0).isBetween(0.5, 2.0, true, false)23assertThat(

Full Screen

Full Screen

Positive

Using AI Code Generation

copy

Full Screen

1 import io.kotest.matchers.doubles.shouldBePositive2 import io.kotest.matchers.doubles.shouldBeNegative3 import io.kotest.matchers.doubles.shouldBeZero4 import io.kotest.matchers.doubles.shouldBeGreaterThan5 import io.kotest.matchers.doubles.shouldBeGreaterThanOrEqual6 import io.kotest.matchers.doubles.shouldBeLessThan7 import io.kotest.matchers.doubles.shouldBeLessThanOrEqual8 import io.kotest.matchers.doubles.shouldBeBetween9 import io.kotest.matchers.doubles.shouldBeCloseTo10 import io.kotest.matchers.doubles.shouldBeExactly11 import io.kotest.matchers.doubles.shouldBeWithin12 import io.kotest.matchers.doubles.shouldBeExactly13 import io.kotest.matchers.doubles.shouldBeWithin14 import io.kotest.matchers.doubles.shouldBeNaN

Full Screen

Full Screen

Positive

Using AI Code Generation

copy

Full Screen

1import io.kotest.matchers.doubles.shouldBePositive2import io.kotest.matchers.string.shouldContain3import io.kotest.matchers.string.shouldEndWith4import io.kotest.matchers.string.shouldStartWith5import io.kotest.matchers.string.shouldNotBeEmpty6import io.kotest.matchers.string.shouldNotContain7import io.kotest.matchers.string.shouldNotEndWith8import io.kotest.matchers.string.shouldNotStartWith9import io.kotest.matchers.string.shouldNotBeBlank10import io.kotest.matchers.string.shouldNotBeEmpty11import io.kotest.matchers.string.shouldNotBeNullOrBlank12import io.kotest.matchers.string.shouldNotBeNullOrEmpty13import io.kotest.matchers.string.shouldNotStartWith14import io.kotest.matchers.string.shouldNotEndWith15import io.kotest.matchers.string.shouldNotBeEmpty16import io.kotest.matchers.string.shouldNotBeBlank17import io.kotest.matchers.string.shouldNotBeNullOrBlank18import io.kotest.matchers.string

Full Screen

Full Screen

Positive

Using AI Code Generation

copy

Full Screen

1Positive(3.4) shouldBe Positive(3.4)2Negative(-3.4) shouldBe Negative(-3.4)3Zero(0.0) shouldBe Zero(0.0)41.0 shouldBe BeCloseTo(1.000000001)51.0 shouldBe BeCloseTo(1.000000001, 0.0000000001)61.0 shouldBe BeCloseTo(1.000000001, 0.0000000001, 0.0000000001)71.0 shouldBe BeGreaterThan(0.9)81.0 shouldBe BeGreaterThan(0.9, 0.0000000001)91.0 shouldBe BeGreaterThan(0.9, 0.0000000001, 0.0000000001)101.0 shouldBe BeGreaterThanOrEqual(0.9)111.0 shouldBe BeGreaterThanOrEqual(0.9, 0.0000000001)121.0 shouldBe BeGreaterThanOrEqual(0.9, 0.0000000001, 0.0000000001)131.0 shouldBe BeLessThan(1.1)141.0 shouldBe BeLessThan(1.1, 0.0000000001)151.0 shouldBe BeLessThan(1.1, 0.0000000001, 0.0000000001)161.0 shouldBe BeLessThanOrEqual(1.1)171.0 shouldBe BeLessThanOrEqual(1.1, 0.0000000001)181.0 shouldBe BeLessThanOrEqual(1.1, 0.0000000001, 0.0000000001)

Full Screen

Full Screen

Positive

Using AI Code Generation

copy

Full Screen

1Positive(3.0) shouldBe Positive(3.0)2Positive(3.0) shouldNotBe Positive(3.1)3Negative(3.0) shouldBe Negative(3.1)4Negative(3.0) shouldNotBe Negative(3.0)5Zero(0.0) shouldBe Zero(0.0)6Zero(3.0) shouldNotBe Zero(0.0)7Greater(3.0) shouldBe Greater(3.1)8Greater(3.0) shouldNotBe Greater(3.0)9GreaterOrEqual(3.0) shouldBe GreaterOrEqual(3.0)10GreaterOrEqual(3.0) shouldBe GreaterOrEqual(3.1)11Less(3.0) shouldBe Less(3.0)12Less(3.0) shouldNotBe Less(3.1)13LessOrEqual(3.0) shouldBe LessOrEqual(3.0)14LessOrEqual(3.0) shouldNotBe LessOrEqual(3.1)15CloseTo(3.0, 0.1) shouldBe CloseTo(3.01, 0.1)16CloseTo(3.0, 0.1) shouldNotBe CloseTo(3.1, 0.1)173.0 shouldBe between(2.0, 4.0)183.0 shouldNotBe between(3.0, 4.0)193.0 shouldBe beGreaterThan(2.0)203.0 shouldNotBe beGreaterThan(3.0)

Full Screen

Full Screen

Positive

Using AI Code Generation

copy

Full Screen

1x should bePositive()2x should beNegative()3x should beLessThan(0.2)4x should beGreaterThan(0.1)5x should beLessThanOrEqual(0.1)6x should beGreaterThanOrEqual(0.1)7x should beBetween(0.0, 0.2)8x should beZero()9x should beCloseTo(0.2, 0.1)10x should beWithin(0.2, 0.1)11x should beExactly(0.1)12x should bePositiveInfinity()13x should beNegativeInfinity()14x should beNaN()

Full Screen

Full Screen

Positive

Using AI Code Generation

copy

Full Screen

1class PositiveMatcherTest : StringSpec() {2 init {3 "Positive matcher test" {4 1.0 should bePositive()5 0.0 shouldNot bePositive()6 -1.0 shouldNot bePositive()7 }8 }9}10class NegativeMatcherTest : StringSpec() {11 init {12 "Negative matcher test" {13 -1.0 should beNegative()14 0.0 shouldNot beNegative()15 1.0 shouldNot beNegative()16 }17 }18}19class LessThanMatcherTest : StringSpec() {20 init {21 "LessThan matcher test" {22 1.0 should beLessThan(2.0)23 1.0 shouldNot beLessThan(1.0)24 2.0 shouldNot beLessThan(1.0)25 }26 }27}28class LessThanOrEqualMatcherTest : StringSpec() {29 init {30 "LessThanOrEqual matcher test" {31 1.0 should beLessThanOrEqual(2.0)32 1.0 should beLessThanOrEqual(1.0)33 2.0 shouldNot beLessThanOrEqual(1.0)34 }35 }36}

Full Screen

Full Screen

Positive

Using AI Code Generation

copy

Full Screen

1 val positive = Positive(0.0)2 positive shouldBe Positive(1.0)3 }4 fun `test with custom matcher`() {5 val positive = Positive(1.0)6 }7}8class Positive(val value: Double) {9 override fun toString(): String {10 return "Positive(value=$value)"11 }12}13class PositiveMatcher : Matcher<Positive> {14 override fun test(value: Positive): MatcherResult {15 return MatcherResult(16 }17}18fun Positive(value: Double) = PositiveMatcher().match(value)19Expected: Positive(value=1.0)20Expected: Positive(value=1.0)21class Positive(val value: Double) {22 override fun toString(): String {23 return "Positive(value=$value)"24 }25}

Full Screen

Full Screen

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.

LambdaTest Learning Hubs:

YouTube

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

Run Kotest automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

... View sample repo... View DocumentationSign up Free
›
_

Most used methods in Positive

Try LambdaTest Now !!

Get 100 minutes of automation test minutes FREE!!

...
Sign up with GoogleSign up with Email
Next-Gen App & Browser Testing Cloud

Was this article helpful?

Helpful

NotHelpful