How to use Double.shouldBeNegativeInfinity method of io.kotest.matchers.doubles.Infinity class

Best Kotest code snippet using io.kotest.matchers.doubles.Infinity.Double.shouldBeNegativeInfinity

DoubleMatchersTest.kt

Source:DoubleMatchersTest.kt

1package com.sksamuel.kotest.matchers.doubles2import io.kotest.assertions.shouldFail3import io.kotest.assertions.throwables.shouldThrow4import io.kotest.core.spec.style.FreeSpec5import io.kotest.matchers.doubles.beGreaterThan6import io.kotest.matchers.doubles.beGreaterThanOrEqualTo7import 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()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}...

FloatingBigRationalTest.kt

Source:FloatingBigRationalTest.kt

1@file:Suppress("NonAsciiCharacters", "RedundantInnerClassModifier")2package hm.binkley.math.floating3import hm.binkley.math.BFixed4import hm.binkley.math.BFloating5import hm.binkley.math.`^`6import hm.binkley.math.big7import hm.binkley.math.ceil8import hm.binkley.math.compareTo9import hm.binkley.math.dec10import hm.binkley.math.divideAndRemainder11import hm.binkley.math.fixed.FixedBigRational12import hm.binkley.math.floating.FloatingBigRational.Companion.NEGATIVE_INFINITY13import hm.binkley.math.floating.FloatingBigRational.Companion.NaN14import hm.binkley.math.floating.FloatingBigRational.Companion.ONE15import hm.binkley.math.floating.FloatingBigRational.Companion.POSITIVE_INFINITY16import hm.binkley.math.floating.FloatingBigRational.Companion.TEN17import hm.binkley.math.floating.FloatingBigRational.Companion.TWO18import hm.binkley.math.floating.FloatingBigRational.Companion.ZERO19import hm.binkley.math.floor20import hm.binkley.math.inc21import hm.binkley.math.isDyadic22import hm.binkley.math.rangeTo23import hm.binkley.math.sqrt24import hm.binkley.math.sqrtApproximated25import hm.binkley.math.toBigInteger26import hm.binkley.math.truncate27import io.kotest.assertions.throwables.shouldThrow28import io.kotest.matchers.booleans.shouldBeFalse29import io.kotest.matchers.booleans.shouldBeTrue30import io.kotest.matchers.shouldBe31import io.kotest.matchers.shouldNotBe32import io.kotest.matchers.types.shouldBeSameInstanceAs33import org.junit.jupiter.api.Nested34import org.junit.jupiter.api.Test35private typealias BigRationalAssertion = (FloatingBigRational) -> Unit36/**37 * NB -- the tests use a mixture of constructors while testing functionality.38 * This is intentional, and raises coverage.39 */40internal class FloatingBigRationalTest {41    @Nested42    inner class ConstructionTests {43        @Test44        fun `should use constant NaN`() {45            (0 over 0) shouldBeSameInstanceAs NaN46        }47        @Test48        fun `should use constant +â`() {49            (Long.MAX_VALUE over 0L) shouldBeSameInstanceAs POSITIVE_INFINITY50        }51        @Test52        fun `should use constant -â`() {53            (Long.MIN_VALUE over 0.big) shouldBeSameInstanceAs NEGATIVE_INFINITY54        }55        @Test56        fun `should provide over as a convenience`() {57            (10L over 1) shouldBe TEN58            (10 over 1L) shouldBe TEN59        }60    }61    @Test62    fun `should not be a floating big rational`() {63        FixedBigRational.valueOf(1.big, 1.big).hashCode() shouldNotBe64            (1 over 1).hashCode()65        (FixedBigRational.ONE..FixedBigRational.TWO) shouldNotBe ONE..TWO66        (FixedBigRational.ONE..FixedBigRational.TWO).hashCode() shouldNotBe67            (ONE..TWO).hashCode()68    }69    @Test70    fun `should pretty print`() {71        POSITIVE_INFINITY.toString() shouldBe "Infinity"72        NEGATIVE_INFINITY.toString() shouldBe "-Infinity"73        NaN.toString() shouldBe "NaN"74    }75    @Test76    fun `should divide with remainder`() {77        fun nonFiniteCheck(78            dividend: FloatingBigRational,79            divisor: FloatingBigRational,80            assertion: BigRationalAssertion,81        ) {82            val (quotient, remainder) = dividend.divideAndRemainder(divisor)83            assertion(quotient)84            assertion(remainder)85        }86        nonFiniteCheck((13 over 2), POSITIVE_INFINITY) {87            it.isPositiveInfinity()88        }89        nonFiniteCheck(POSITIVE_INFINITY, (3 over 1)) {90            it.isPositiveInfinity()91        }92        nonFiniteCheck(POSITIVE_INFINITY, POSITIVE_INFINITY) {93            it.isPositiveInfinity()94        }95        nonFiniteCheck((13 over 2), NEGATIVE_INFINITY) {96            it.isNegativeInfinity()97        }98        nonFiniteCheck(NEGATIVE_INFINITY, (3 over 1)) {99            it.isNegativeInfinity()100        }101        nonFiniteCheck(NEGATIVE_INFINITY, NEGATIVE_INFINITY) {102            it.isPositiveInfinity()103        }104        nonFiniteCheck((13 over 2), NaN) {105            it.isNaN()106        }107        nonFiniteCheck(NaN, (3 over 1)) {108            it.isNaN()109        }110        nonFiniteCheck(NaN, NaN) {111            it.isNaN()112        }113    }114    @Nested115    inner class OperatorTests {116        @Test117        fun `should add`() {118            (ONE + POSITIVE_INFINITY).shouldBePositiveInfinity()119            (POSITIVE_INFINITY + POSITIVE_INFINITY).shouldBePositiveInfinity()120            (POSITIVE_INFINITY + NEGATIVE_INFINITY).shouldBeNaN()121            (ONE + NEGATIVE_INFINITY).shouldBeNegativeInfinity()122            (NEGATIVE_INFINITY + NEGATIVE_INFINITY).shouldBeNegativeInfinity()123            (NEGATIVE_INFINITY + POSITIVE_INFINITY).shouldBeNaN()124        }125        @Test126        fun `should subtract`() {127            (POSITIVE_INFINITY - ONE).shouldBePositiveInfinity()128            (POSITIVE_INFINITY - POSITIVE_INFINITY).shouldBeNaN()129            (POSITIVE_INFINITY - NEGATIVE_INFINITY).shouldBePositiveInfinity()130            (NEGATIVE_INFINITY - ONE).shouldBeNegativeInfinity()131            (NEGATIVE_INFINITY - NEGATIVE_INFINITY).shouldBeNaN()132            (NEGATIVE_INFINITY - POSITIVE_INFINITY).shouldBeNegativeInfinity()133        }134        @Test135        fun `should multiply`() {136            (ONE * POSITIVE_INFINITY).shouldBePositiveInfinity()137            (ONE * NEGATIVE_INFINITY).shouldBeNegativeInfinity()138            (ZERO * POSITIVE_INFINITY).shouldBeNaN()139            (POSITIVE_INFINITY * ZERO).shouldBeNaN()140            (ZERO * NEGATIVE_INFINITY).shouldBeNaN()141            (NEGATIVE_INFINITY * ZERO).shouldBeNaN()142            (POSITIVE_INFINITY * POSITIVE_INFINITY).shouldBePositiveInfinity()143        }144        @Test145        fun `should divide`() {146            (ZERO / POSITIVE_INFINITY) shouldBe ZERO147            (ONE / ZERO).shouldBePositiveInfinity()148            (ZERO / NEGATIVE_INFINITY) shouldBe ZERO149            (-ONE / ZERO).shouldBeNegativeInfinity()150            (NEGATIVE_INFINITY / NEGATIVE_INFINITY).shouldBeNaN()151            (POSITIVE_INFINITY / POSITIVE_INFINITY).shouldBeNaN()152            (ONE / NaN).shouldBeNaN()153            (NaN / ONE).shouldBeNaN()154            (ZERO / ZERO).shouldBeNaN()155        }156        @Test157        fun `should find remainder`() {158            (ONE % POSITIVE_INFINITY) shouldBe ZERO159            (POSITIVE_INFINITY % ONE) shouldBe ZERO160            (ONE % NEGATIVE_INFINITY) shouldBe ZERO161            (NEGATIVE_INFINITY % ONE) shouldBe ZERO162            (ONE % NaN).shouldBeNaN()163            (NaN % ONE).shouldBeNaN()164            (ZERO % ZERO).shouldBeNaN()165        }166        @Test167        fun `should increment`() {168            var nonFinite = POSITIVE_INFINITY169            (++nonFinite).shouldBePositiveInfinity()170            nonFinite = NEGATIVE_INFINITY171            (++nonFinite).shouldBeNegativeInfinity()172            nonFinite = NaN173            (++nonFinite).shouldBeNaN()174        }175        @Test176        fun `should decrement`() {177            var nonFinite = POSITIVE_INFINITY178            (--nonFinite).shouldBePositiveInfinity()179            nonFinite = NEGATIVE_INFINITY180            (--nonFinite).shouldBeNegativeInfinity()181            nonFinite = NaN182            (--nonFinite).shouldBeNaN()183        }184    }185    @Nested186    inner class RoundingTests {187        @Test188        fun `should round towards ceiling`() {189            POSITIVE_INFINITY.ceil().shouldBePositiveInfinity()190            NEGATIVE_INFINITY.ceil().shouldBeNegativeInfinity()191            NaN.ceil().shouldBeNaN()192        }193        @Test194        fun `should round towards floor`() {195            POSITIVE_INFINITY.floor().shouldBePositiveInfinity()196            NEGATIVE_INFINITY.floor().shouldBeNegativeInfinity()197            NaN.floor().shouldBeNaN()198        }199        @Test200        fun `should round towards 0`() {201            POSITIVE_INFINITY.truncate().shouldBePositiveInfinity()202            NEGATIVE_INFINITY.truncate().shouldBeNegativeInfinity()203            NaN.truncate().shouldBeNaN()204        }205    }206    @Nested207    inner class SpecialCasesTests {208        @Test209        fun `should round trip NaN and infinities`() {210            POSITIVE_INFINITY.toDouble().toBigRational() shouldBe211                POSITIVE_INFINITY212            NEGATIVE_INFINITY.toDouble().toBigRational() shouldBe213                NEGATIVE_INFINITY214            NaN.toDouble().toBigRational() shouldBe NaN215            POSITIVE_INFINITY.toFloat().toBigRational() shouldBe216                POSITIVE_INFINITY217            NEGATIVE_INFINITY.toFloat().toBigRational() shouldBe218                NEGATIVE_INFINITY219            NaN.toFloat().toBigRational() shouldBe NaN220        }221        @Test222        fun `should be infinity`() {223            (2 over 0).shouldBePositiveInfinity()224            (-2 over 0).shouldBeNegativeInfinity()225        }226        @Test227        fun `should check finitude`() {228            ZERO.isFinite().shouldBeTrue()229            POSITIVE_INFINITY.isFinite().shouldBeFalse()230            NEGATIVE_INFINITY.isFinite().shouldBeFalse()231            NaN.isFinite().shouldBeFalse()232        }233        @Test234        fun `should check infinitude`() {235            ZERO.isInfinite().shouldBeFalse()236            POSITIVE_INFINITY.isInfinite().shouldBeTrue()237            NEGATIVE_INFINITY.isInfinite().shouldBeTrue()238            NaN.isInfinite().shouldBeFalse()239        }240        @Test241        fun `should propagate NaN`() {242            (ZERO + NaN).shouldBeNaN()243            (NaN + NaN).shouldBeNaN()244            (NaN + ONE).shouldBeNaN()245            (NaN - ZERO).shouldBeNaN()246            (NaN - NaN).shouldBeNaN()247            (ZERO - NaN).shouldBeNaN()248            (ONE * NaN).shouldBeNaN()249            (NaN * NaN).shouldBeNaN()250            (NaN * ONE).shouldBeNaN()251            (NaN / ONE).shouldBeNaN()252            (NaN / NaN).shouldBeNaN()253            (ONE / NaN).shouldBeNaN()254            (NaN % ONE).shouldBeNaN()255            (NaN % NaN).shouldBeNaN()256            (ONE % NaN).shouldBeNaN()257        }258        @Test259        fun `should propagate infinities`() {260            (-NEGATIVE_INFINITY).shouldBePositiveInfinity()261            (ONE + POSITIVE_INFINITY).shouldBePositiveInfinity()262            (NEGATIVE_INFINITY - ONE).shouldBeNegativeInfinity()263            (POSITIVE_INFINITY + NEGATIVE_INFINITY).shouldBeNaN()264            (POSITIVE_INFINITY * POSITIVE_INFINITY).shouldBePositiveInfinity()265            (POSITIVE_INFINITY * NEGATIVE_INFINITY).shouldBeNegativeInfinity()266            (NEGATIVE_INFINITY * NEGATIVE_INFINITY).shouldBePositiveInfinity()267            (POSITIVE_INFINITY / POSITIVE_INFINITY).shouldBeNaN()268            (POSITIVE_INFINITY / NEGATIVE_INFINITY).shouldBeNaN()269            (NEGATIVE_INFINITY / NEGATIVE_INFINITY).shouldBeNaN()270        }271        @Test272        fun `should invert infinities incorrectly`() {273            (ONE / POSITIVE_INFINITY) shouldBe ZERO274            (ONE / NEGATIVE_INFINITY) shouldBe ZERO275        }276        @Test277        fun `should cope with various infinities`() {278            (ZERO * POSITIVE_INFINITY).shouldBeNaN()279            (ZERO / POSITIVE_INFINITY) shouldBe ZERO280            (POSITIVE_INFINITY / ZERO).shouldBePositiveInfinity()281            (ZERO * NEGATIVE_INFINITY).shouldBeNaN()282            (ZERO / NEGATIVE_INFINITY) shouldBe ZERO283            (NEGATIVE_INFINITY / ZERO).shouldBeNegativeInfinity()284            (POSITIVE_INFINITY * NEGATIVE_INFINITY).shouldBeNegativeInfinity()285            (POSITIVE_INFINITY / NEGATIVE_INFINITY).shouldBeNaN()286        }287        @Test288        fun `should understand equalities of non-finite values`() {289            POSITIVE_INFINITY shouldBe POSITIVE_INFINITY290            NEGATIVE_INFINITY shouldBe NEGATIVE_INFINITY291            // Cannot use shouldNotBe: It short-circuits for === objects292            @Suppress("KotlinConstantConditions")293            (NaN == NaN).shouldBeFalse()294        }295    }296    @Test297    fun `should note integer rationals`() {298        POSITIVE_INFINITY.isWhole().shouldBeFalse()299        NEGATIVE_INFINITY.isWhole().shouldBeFalse()300        NaN.isWhole().shouldBeFalse()301    }302    @Test303    fun `should note p-adic rationals`() {304        (1 over 3).isPAdic(3).shouldBeTrue()305        (2 over 5).isPAdic(3).shouldBeFalse()306        POSITIVE_INFINITY.isPAdic(3).shouldBeFalse()307        NEGATIVE_INFINITY.isPAdic(3).shouldBeFalse()308        NaN.isPAdic(3).shouldBeFalse()309    }310    @Test311    fun `should note dyadic rationals`() {312        (1 over 2).isDyadic().shouldBeTrue()313        POSITIVE_INFINITY.isDyadic().shouldBeFalse()314        NEGATIVE_INFINITY.isDyadic().shouldBeFalse()315        NaN.isDyadic().shouldBeFalse()316    }317    @Nested318    inner class ProgressionTests {319        @Test320        fun `should equate`() {321            (ONE..TEN).equals(this).shouldBeFalse()322            (ONE..TEN) shouldNotBe323                FixedBigRational.ONE..FixedBigRational.TEN324            (ONE..TEN).hashCode() shouldNotBe325                (FixedBigRational.ONE..FixedBigRational.TEN).hashCode()326        }327    }328    @Nested329    inner class ConversionTests {330        @Test331        fun `should be a number`() {332            ONE.toDouble() shouldBe 1.0333            POSITIVE_INFINITY.toDouble() shouldBe Double.POSITIVE_INFINITY334            NEGATIVE_INFINITY.toDouble() shouldBe Double.NEGATIVE_INFINITY335            NaN.toDouble() shouldBe Double.NaN336            ONE.toFloat() shouldBe 1.0f337            POSITIVE_INFINITY.toFloat() shouldBe Float.POSITIVE_INFINITY338            NEGATIVE_INFINITY.toFloat() shouldBe Float.NEGATIVE_INFINITY339            NaN.toFloat() shouldBe Float.NaN340        }341        @Test342        fun `should not convert extrema to big decimal`() {343            // Note JDK rules for BigDecimal->Double->BigDecimal, and handling344            // of string _vs_ double/long inputs345            ONE.toBigDecimal() shouldBe BFloating("1.0")346            ONE.toBigDecimal(1) shouldBe BFloating("1.0")347            shouldThrow<ArithmeticException> {348                POSITIVE_INFINITY.toBigDecimal()349            }350            shouldThrow<ArithmeticException> {351                POSITIVE_INFINITY.toBigDecimal(1)352            }353            shouldThrow<ArithmeticException> {354                NEGATIVE_INFINITY.toBigDecimal()355            }356            shouldThrow<ArithmeticException> {357                NEGATIVE_INFINITY.toBigDecimal(1)358            }359            shouldThrow<ArithmeticException> {360                NaN.toBigDecimal()361            }362            shouldThrow<ArithmeticException> {363                NaN.toBigDecimal(1)364            }365        }366        @Test367        fun `should not convert extrema to big integer`() {368            ONE.toBigInteger() shouldBe BFixed.ONE369            shouldThrow<ArithmeticException> {370                POSITIVE_INFINITY.toBigInteger()371            }372            shouldThrow<ArithmeticException> {373                NEGATIVE_INFINITY.toBigInteger()374            }375            shouldThrow<ArithmeticException> {376                NaN.toBigInteger()377            }378        }379        @Test380        fun `should not convert extrema to long`() {381            shouldThrow<ArithmeticException> {382                POSITIVE_INFINITY.toLong()383            }384            shouldThrow<ArithmeticException> {385                NEGATIVE_INFINITY.toLong()386            }387            shouldThrow<ArithmeticException> {388                NaN.toLong()389            }390        }391        @Test392        fun `should not convert extrema to int`() {393            shouldThrow<ArithmeticException> {394                POSITIVE_INFINITY.toInt()395            }396            shouldThrow<ArithmeticException> {397                NEGATIVE_INFINITY.toInt()398            }399            shouldThrow<ArithmeticException> {400                NaN.toInt()401            }402        }403        @Test404        fun `should convert big decimal in infix constructor`() {405            0.0.big.toBigRational() shouldBe ZERO406            30.0.big.toBigRational() shouldBe (30 over 1)407            3.0.big.toBigRational() shouldBe (3 over 1)408            BFloating("0.3").toBigRational() shouldBe (3 over 10)409            BFloating("7.70").toBigRational() shouldBe (77 over 10)410            (1.0.big over 1.0.big) shouldBe ONE411            (1.big over 1.0.big) shouldBe ONE412            (1L over 1.0.big) shouldBe ONE413            (1 over 1.0.big) shouldBe ONE414            (1.0 over 1.0.big) shouldBe ONE415            (1.0f over 1.0.big) shouldBe ONE416            (1.0.big over 1L) shouldBe ONE417            (1.0.big over 1) shouldBe ONE418        }419        @Test420        fun `should convert big integer in infix constructor`() {421            0.big.toBigRational() shouldBe ZERO422            BFixed.valueOf(30L).toBigRational() shouldBe (30 over 1)423            3.big.toBigRational() shouldBe (3 over 1)424            (1.big over 1.big) shouldBe ONE425            (1.0.big over 1.big) shouldBe ONE426            (1L over 1.big) shouldBe ONE427            (1 over 1.big) shouldBe ONE428            (1.0 over 1.big) shouldBe ONE429            (1.0f over 1.big) shouldBe ONE430            (1.big over 1L) shouldBe ONE431            (1.big over 1) shouldBe ONE432        }433        @Test434        fun `should convert double in infix constructor`() {435            (1.0.big over 1.0) shouldBe ONE436            (1.big over 1.0) shouldBe ONE437            (1L over 1.0) shouldBe ONE438            (1 over 1.0) shouldBe ONE439            (1.0 over 1.0) shouldBe ONE440            (1.0f over 1.0) shouldBe ONE441            (1.0 over 1.big) shouldBe ONE442            (1.0 over 1L) shouldBe ONE443            (1.0 over 1) shouldBe ONE444        }445        @Test446        fun `should convert float in infix constructor`() {447            (1.0.big over 1.0f) shouldBe ONE448            (1.big over 1.0f) shouldBe ONE449            (1L over 1.0f) shouldBe ONE450            (1 over 1.0f) shouldBe ONE451            (1.0 over 1.0f) shouldBe ONE452            (1.0f over 1.0f) shouldBe ONE453            (1.0f over 1.big) shouldBe ONE454            (1.0f over 1L) shouldBe ONE455            (1.0f over 1) shouldBe ONE456        }457        @Test458        fun `should convert from double`() {459            val doubles = listOf(460                -4.0,461                -3.0,462                -2.0,463                -1.0,464                -0.5,465                -0.3,466                -0.1,467                0.0,468                0.1,469                0.3,470                0.5,471                1.0,472                2.0,473                3.0,474                4.0,475                10.0,476                123.456477            )478            val rationals = listOf(479                -4 over 1,480                -3 over 1,481                -2 over 1,482                -1 over 1,483                -1 over 2,484                -3 over 10,485                -1 over 10,486                ZERO,487                1 over 10,488                3 over 10,489                1 over 2,490                ONE,491                TWO,492                3 over 1,493                4 over 1,494                TEN,495                15432 over 125496            )497            Double.POSITIVE_INFINITY.toBigRational().shouldBePositiveInfinity()498            Double.NEGATIVE_INFINITY.toBigRational().shouldBeNegativeInfinity()499            Double.NaN.toBigRational().shouldBeNaN()500            (-0.0).toBigRational() shouldBe ZERO501            doubles.map {502                it.toBigRational()503            } shouldBe rationals504            rationals.map {505                it.toDouble()506            } shouldBe doubles507        }508        @Test509        fun `should convert from float`() {510            val floats = listOf(511                -4.0f,512                -3.0f,513                -2.0f,514                -1.0f,515                -0.5f,516                -0.3f,517                -0.1f,518                0.0f,519                0.1f,520                0.3f,521                0.5f,522                1.0f,523                2.0f,524                3.0f,525                4.0f,526                10.0f,527                123.456f528            )529            val rationals = listOf(530                -4 over 1,531                -3 over 1,532                -2 over 1,533                -1 over 1,534                -1 over 2,535                -3 over 10,536                -1 over 10,537                ZERO,538                1 over 10,539                3 over 10,540                1 over 2,541                ONE,542                TWO,543                3 over 1,544                4 over 1,545                TEN,546                15432 over 125547            )548            Float.POSITIVE_INFINITY.toBigRational().shouldBePositiveInfinity()549            Float.NEGATIVE_INFINITY.toBigRational().shouldBeNegativeInfinity()550            Float.NaN.toBigRational().shouldBeNaN()551            (-0.0f).toBigRational() shouldBe ZERO552            floats.map {553                it.toBigRational()554            } shouldBe rationals555            rationals.map {556                it.toFloat()557            } shouldBe floats558        }559        @Test560        fun `should convert to fixed equivalent or complain`() {561            ONE.toFixedBigRational() shouldBe FixedBigRational.ONE562            shouldThrow<ArithmeticException> {563                NaN.toFixedBigRational()564            }565            shouldThrow<ArithmeticException> {566                POSITIVE_INFINITY.toFixedBigRational()567            }568            shouldThrow<ArithmeticException> {569                NEGATIVE_INFINITY.toFixedBigRational()570            }571        }572    }573    @Nested574    inner class FunctionTests {575        @Test576        fun `should sort like double`() {577            val sorted = listOf(578                POSITIVE_INFINITY,579                NaN,580                ZERO,581                POSITIVE_INFINITY,582                NaN,583                NEGATIVE_INFINITY,584                ZERO,585                NEGATIVE_INFINITY586            ).sorted()587            val doubleSorted = listOf(588                Double.POSITIVE_INFINITY,589                Double.NaN,590                0.0,591                Double.POSITIVE_INFINITY,592                Double.NaN,593                Double.NEGATIVE_INFINITY,594                0.0,595                Double.NEGATIVE_INFINITY596            ).sorted()597            (sorted.map { it.toDouble() }) shouldBe doubleSorted598        }599        @Test600        fun `should compare other number types`() {601            (Double.POSITIVE_INFINITY > ZERO).shouldBeTrue()602            (ZERO > Double.NEGATIVE_INFINITY).shouldBeTrue()603            (Float.NaN > ZERO).shouldBeTrue()604            (NaN > Float.MAX_VALUE).shouldBeTrue()605        }606        @Test607        fun `should not order NaN values`() {608            @Suppress("KotlinConstantConditions")609            (NaN == NaN).shouldBeFalse()610            (NaN > NaN).shouldBeFalse()611            (NaN < NaN).shouldBeFalse()612        }613        @Test614        fun `should reciprocate`() {615            POSITIVE_INFINITY.unaryDiv() shouldBe ZERO616            NEGATIVE_INFINITY.unaryDiv() shouldBe ZERO617            NaN.unaryDiv().shouldBeNaN()618        }619        @Test620        fun `should absolute`() {621            NaN.absoluteValue.shouldBeNaN()622            POSITIVE_INFINITY.absoluteValue623                .shouldBePositiveInfinity()624            NEGATIVE_INFINITY.absoluteValue625                .shouldBePositiveInfinity()626        }627        @Test628        fun `should signum`() {629            ZERO.sign shouldBe ZERO630            NEGATIVE_INFINITY.sign shouldBe -ONE631            POSITIVE_INFINITY.sign shouldBe ONE632            NaN.sign.shouldBeNaN()633        }634        @Test635        fun `should raise`() {636            POSITIVE_INFINITY `^` 2 shouldBe POSITIVE_INFINITY637            POSITIVE_INFINITY `^` -1 shouldBe ZERO638            NEGATIVE_INFINITY `^` 3 shouldBe NEGATIVE_INFINITY639            NEGATIVE_INFINITY `^` 2 shouldBe POSITIVE_INFINITY640            NEGATIVE_INFINITY `^` -1 shouldBe ZERO641            (NaN `^` 2).shouldBeNaN()642            (POSITIVE_INFINITY `^` 0).shouldBeNaN()643            (NEGATIVE_INFINITY `^` 0).shouldBeNaN()644        }645        @Test646        fun `should square root`() {647            NaN.sqrt().shouldBeNaN()648            POSITIVE_INFINITY.sqrt() shouldBe POSITIVE_INFINITY649        }650        @Test651        fun `should square root approximately`() {652            NaN.sqrtApproximated().shouldBeNaN()653            POSITIVE_INFINITY.sqrtApproximated() shouldBe POSITIVE_INFINITY654        }655        @Test656        fun `should find between`() {657            NaN.mediant(NaN).shouldBeNaN()658            NaN.mediant(POSITIVE_INFINITY).shouldBeNaN()659            NaN.mediant(NEGATIVE_INFINITY).shouldBeNaN()660            POSITIVE_INFINITY.mediant(POSITIVE_INFINITY)661                .shouldBePositiveInfinity()662            NEGATIVE_INFINITY.mediant(NEGATIVE_INFINITY)663                .shouldBeNegativeInfinity()664            NaN.mediant(ZERO).shouldBeNaN()665            ZERO.mediant(NaN).shouldBeNaN()666            POSITIVE_INFINITY.mediant(NaN).shouldBeNaN()667            NEGATIVE_INFINITY.mediant(NaN).shouldBeNaN()668            POSITIVE_INFINITY.mediant(NEGATIVE_INFINITY) shouldBe ZERO669            NEGATIVE_INFINITY.mediant(POSITIVE_INFINITY) shouldBe ZERO670            POSITIVE_INFINITY.mediant(ZERO) shouldBe ONE671            ZERO.mediant(POSITIVE_INFINITY) shouldBe ONE672            ZERO.mediant(NEGATIVE_INFINITY) shouldBe -ONE673            NEGATIVE_INFINITY.mediant(ZERO) shouldBe -ONE674        }675        @Test676        fun `should find continued fraction`() {677            val cfA = (3245 over 1000).toContinuedFraction()678            cfA.isFinite().shouldBeTrue()679            val negCfA = (-3245 over 1000).toContinuedFraction()680            negCfA.isFinite().shouldBeTrue()681            val cfNaN = NaN.toContinuedFraction()682            cfNaN.isFinite().shouldBeFalse()683            cfNaN.toBigRational().shouldBeNaN()684            cfNaN.integerPart.shouldBeNaN()685            val cfPosInf = POSITIVE_INFINITY.toContinuedFraction()686            cfPosInf.isFinite().shouldBeFalse()687            cfPosInf.toBigRational().shouldBeNaN()688            cfPosInf.integerPart.shouldBeNaN()689            val cfNegInf = NEGATIVE_INFINITY.toContinuedFraction()690            cfNegInf.isFinite().shouldBeFalse()691            cfNegInf.toBigRational().shouldBeNaN()692            cfNegInf.integerPart.shouldBeNaN()693        }694    }695}696private fun FloatingBigRational.shouldBePositiveInfinity() =697    isPositiveInfinity().shouldBeTrue()698private fun FloatingBigRational.shouldBeNegativeInfinity() =699    isNegativeInfinity().shouldBeTrue()700private fun FloatingBigRational.shouldBeNaN() = isNaN().shouldBeTrue()...

Infinity.kt

Source:Infinity.kt

1package io.kotest.matchers.doubles2import io.kotest.matchers.Matcher3import io.kotest.matchers.MatcherResult4import io.kotest.matchers.should5import io.kotest.matchers.shouldNot6/**7 * Verifies that this double is [Double.POSITIVE_INFINITY]8 *9 * Opposite of [shouldNotBePositiveInfinity]10 *11 * ```12 * Double.POSITIVE_INFINITY.shouldBePositiveInfinity()    // Assertion passes13 * 1.0.shouldBePositiveInfinity()                         // Assertion fails14 * ```15 *16 * @see [bePositiveInfinity]17 */18fun Double.shouldBePositiveInfinity() = this should bePositiveInfinity()19/**20 * Verifies that this double is NOT [Double.POSITIVE_INFINITY]21 *22 * Opposite of [shouldBePositiveInfinity]23 *24 * ```25 * Double.POSITIVE_INFINITY.shouldNotBePositiveInfinity()       // Assertion fails26 * 1.0.shouldBeNotPositiveInfinity()                            // Assertion passes27 * ```28 *29 * @see [bePositiveInfinity]30 */31fun Double.shouldNotBePositiveInfinity() = this shouldNot bePositiveInfinity()32/**33 * Matcher that matches whether a double is [Double.POSITIVE_INFINITY] or not34 *35 * ```36 * Double.POSITIVE_INFINITY should bePositiveInfinity()   // Assertion passes37 * 1.0 should bePositiveInfinity()                        // Assertion fails38 * ```39 */40fun bePositiveInfinity() = object : Matcher<Double> {41  override fun test(value: Double) = MatcherResult(42    value == Double.POSITIVE_INFINITY,43    "$value should be POSITIVE_INFINITY",44    "$value should not be POSITIVE_INFINITY"45  )46}47/**48 * Verifies that this double is [Double.NEGATIVE_INFINITY]49 *50 * Opposite of [shouldNotBeNegativeInfinity]51 *52 * ```53 * Double.NEGATIVE_INFINITY.shouldBeNegativeInfinity()    // Assertion passes54 * 1.0.shouldBeNegativeInfinity()                         // Assertion fails55 * ```56 *57 * @see [beNegativeInfinity]58 */59fun Double.shouldBeNegativeInfinity() = this should beNegativeInfinity()60/**61 * Verifies that this double is NOT [Double.NEGATIVE_INFINITY]62 *63 * Opposite of [shouldBeNegativeInfinity]64 *65 * ```66 * Double.NEGATIVE_INFINITY.shouldNotBeNegativeInfinity()       // Assertion fails67 * 1.0.shouldBeNotNegativeInfinity()                            // Assertion passes68 * ```69 *70 * @see [beNegativeInfinity]71 */72fun Double.shouldNotBeNegativeInfinity() = this shouldNot beNegativeInfinity()73/**74 * Matcher that matches whether a double is [Double.NEGATIVE_INFINITY] or not75 *76 * ```77 * Double.NEGATIVE_INFINITY should beNegativeInfinity()   // Assertion passes78 * 1.0 should beNegativeInfinity()                        // Assertion fails79 * ```80 */81fun beNegativeInfinity() = object : Matcher<Double> {82  override fun test(value: Double) = MatcherResult(83    value == Double.NEGATIVE_INFINITY,84    "$value should be NEGATIVE_INFINITY",85    "$value should not be NEGATIVE_INFINITY"86  )87}...

Double.shouldBeNegativeInfinity

Using AI Code Generation

1double . shouldBeNegativeInfinity ()2double . shouldBePositiveInfinity ()3double . shouldBeZero ()4double . shouldBeNonZero ()5double . shouldBeNaN ()6double . shouldBeNormal ()7double . shouldBeSubnormal ()8double . shouldBeInfinite ()9double . shouldBeFinite ()10double . shouldBePositive ()11double . shouldBeNegative ()12double . shouldBeNonPositive ()13double . shouldBeNonNegative ()14double . shouldBeCloseTo ( 1.0 , 0.1 )15double . shouldBeGreaterThan ( 1.0 )16double . shouldBeGreaterThanOrEqual ( 1.0 )17double . shouldBeLessThan ( 1.0 )

Double.shouldBeNegativeInfinity

Using AI Code Generation

1Double . shouldBeNegativeInfinity ( 0.0 )2Double . shouldBeNegativeInfinity ( 0.0 )3Double . shouldBeNegativeInfinity ( 0.0 )4Double . shouldBeNegativeInfinity ( 0.0 )5Double . shouldBeNegativeInfinity ( 0.0 )6Double . shouldBeNegativeInfinity ( 0.0 )7Double . shouldBeNegativeInfinity ( 0.0 )8Double . shouldBeNegativeInfinity ( 0.0 )9Double . shouldBeNegativeInfinity ( 0.0 )10Double . shouldBeNegativeInfinity ( 0.0 )11Double . shouldBeNegativeInfinity ( 0.0 )12Double . shouldBeNegativeInfinity ( 0.0 )13Double . shouldBeNegativeInfinity ( 0.0 )14Double . shouldBeNegativeInfinity ( 0.0 )15Double . shouldBeNegativeInfinity ( 0.0 )

Double.shouldBeNegativeInfinity

Using AI Code Generation

1import io.kotest.matchers.doubles.Infinity2import io.kotest.matchers.doubles.shouldBeNegativeInfinity3fun main() {4    negativeInfinity.shouldBeNegativeInfinity()5}6import io.kotest.matchers.doubles.Infinity7import io.kotest.matchers.doubles.shouldBePositiveInfinity8fun main() {9    positiveInfinity.shouldBePositiveInfinity()10}11import io.kotest.matchers.doubles.Finite12import io.kotest.matchers.doubles.shouldBeFinite13fun main() {14    finite.shouldBeFinite()15}16import io.kotest.matchers.doubles.Infinite17import io.kotest.matchers.doubles.shouldBeInfinite18fun main() {19    positiveInfinity.shouldBeInfinite()20}21import io.kotest.matchers.doubles.NaN22import io.kotest.matchers.doubles.shouldBeNaN23fun main() {24    nan.shouldBeNaN()25}26import io.kotest.matchers.doubles.Normal27import io.kotest.matchers.doubles.shouldBeNormal28fun main() {29    normal.shouldBeNormal()30}31import io.kotest.matchers.doubles.Subnormal32import io.kotest.matchers.doubles.shouldBeSubnormal33fun main() {

Double.shouldBeNegativeInfinity

Using AI Code Generation

1@kotlin . test . Test fun testInfinite () { 1.0 / 0.0 shouldBeNegativeInfinity }2@kotlin . test . Test fun testInfinite () { - 1.0 / 0.0 shouldBePositiveInfinity }3@kotlin . test . Test fun testInfinite () { 0.0 / 0.0 shouldBeNaN }4@kotlin . test . Test fun testInfinite () { 1.0 shouldBeNormal }5@kotlin . test . Test fun testInfinite () { 0.0 shouldBeZero }6@kotlin . test . Test fun testInfinite () { 0.0 shouldBeFinite }7@kotlin . test . Test fun testInfinite () { 1.0 / 0.0 shouldBeInfinite }8@kotlin . test . Test fun testInfinite () { 0.0 / 0.0 shouldBeNotNormal }9@kotlin . test . Test fun testInfinite () { 1.0 shouldBeNotZero }10@kotlin . test . Test fun testInfinite () { 1.0 / 0.0 shouldBeNotFinite }11@kotlin . test . Test fun testInfinite () { 1.0 shouldBeNotInfinite }12import io.kotest.matchers.doubles.Subnormal13import io.kotest.matchers.doubles.shouldBeSubnormal14fun main() {

Double.shouldBeNegativeInfinity

Using AI Code Generation

1import io.kotest.matchers.doubles.Infinity2import io.kotest.matchers.doubles.shouldBeNegativeInfinity3fun main() {4    negativeInfinity.shouldBeNegativeInfinity()5}6import io.kotest.matchers.doubles.Infinity7import io.kotest.matchers.doubles.shouldBePositiveInfinity8fun main() {9    positiveInfinity.shouldBePositiveInfinity()10}11import io.kotest.matchers.doubles.Finite12import io.kotest.matchers.doubles.shouldBeFinite13fun main() {14    finite.shouldBeFinite()15}16import io.kotest.matchers.doubles.Infinite17import io.kotest.matchers.doubles.shouldBeInfinite18fun main() {19    positiveInfinity.shouldBeInfinite()20}21import io.kotest.matchers.doubles.NaN22import io.kotest.matchers.doubles.shouldBeNaN23fun main() {24    nan.shouldBeNaN()25}26import io.kotest.matchers.doubles.Normal27import io.kotest.matchers.doubles.shouldBeNormal28fun main() {29    normal.shouldBeNormal()30}31import io.kotest.matchers.doubles.Subnormal32import io.kotest.matchers.doubles.shouldBeSubnormal33fun main() {

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.