Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use test method of io.kotest.matchers.doubles.NaN class

Best Kotest code snippet using io.kotest.matchers.doubles.NaN.test

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) {...

FixedBigRationalTest.kt

Source:FixedBigRationalTest.kt

...8import hm.binkley.math.fixed.FixedBigRational.Companion.ZERO9import hm.binkley.math.fixed.FixedBigRational.Companion.valueOf10import hm.binkley.math.floating.FloatingBigRational11import hm.binkley.math.rangeTo12import io.kotest.assertions.throwables.shouldThrow13import io.kotest.matchers.booleans.shouldBeFalse14import io.kotest.matchers.shouldBe15import io.kotest.matchers.shouldNotBe16import org.junit.jupiter.api.Nested17import org.junit.jupiter.api.Test18/**19 * NB -- the tests use a mixture of constructors while testing functionality.20 * This is intentional, and raises coverage.21 */22@Suppress("RedundantInnerClassModifier")23internal class FixedBigRationalTest {24    @Test25    fun `should not divide by 0 when constructing`() {26        shouldThrow<ArithmeticException> {27            (1 over 0)28        }29    }30    @Nested31    inner class ProgressionTests {32        @Test33        fun `should equate`() {...

TestMapping.kt

Source:TestMapping.kt

1package org.openrndr.math2import kotlin.math.absoluteValue3import io.kotest.matchers.doubles.between4import io.kotest.matchers.doubles.plusOrMinus5import io.kotest.matchers.shouldBe6import io.kotest.matchers.shouldNotBe7import org.openrndr.math.test.it8import org.openrndr.math.test.it as describe9import kotlin.test.Test10class TestMapping {11    @Test12    fun shouldDoMappingOperations() {13        describe("Mapping Double from zero-width before domain to non-zero-width after domain") {14            it("should not produce NaN results") {15                map(0.0, 0.0, 0.0, 1.0, 0.0) shouldBe (0.0 plusOrMinus 10E-6)16                map(0.0, 0.0, 0.0, 1.0, 1.0) shouldBe (1.0 plusOrMinus 10E-6)17            }18        }19        describe("Mapping Double from zero-width before domain to zero-width after domain") {20            it("should not produce NaN results") {21                map(0.0, 0.0, 0.0, 0.0, 0.0) shouldBe (0.0 plusOrMinus 10E-6)22                map(0.0, 0.0, 0.0, 0.0, 1.0) shouldBe (0.0 plusOrMinus 10E-6)23            }24        }25        describe("Mapping Double") {26            val beforeLeft = 0.027            val beforeRight = 1.028            val beforeVal = beforeRight * 2.0 // out of range29            val afterLeft = 0.030            val afterRight = beforeRight * 2.031            it("should not clamp") {32                map(33                    beforeLeft, beforeRight, afterLeft, afterRight, beforeVal34                ) shouldNotBe between(afterLeft, afterRight, 0.0)35            }36            it("should clamp") {37                map(38                    beforeLeft, beforeRight, afterLeft, afterRight, beforeVal, true39                ) shouldBe between(afterLeft, afterRight, 0.0)40            }41            it("should not clamp") {42                beforeVal.map(43                    beforeLeft, beforeRight, afterLeft, afterRight44                ) shouldNotBe between(afterLeft, afterRight, 0.0)45            }46            it("should clamp") {47                beforeVal.map(48                    beforeLeft, beforeRight, afterLeft, afterRight, true49                ) shouldBe between(afterLeft, afterRight, 0.0)50            }51        }52        describe("Mapping Vector2") {53            val beforeLeft = Vector2.ZERO54            val beforeRight = Vector2.ONE55            val beforeVal = beforeRight * 2.0 // out of range56            val afterLeft = Vector2.ZERO57            val afterRight = beforeRight * 2.058            it("should not clamp") {59                val mapped = beforeVal.map(beforeLeft, beforeRight,60                    afterLeft, afterRight)61                for (i in 0 until 2)62                    mapped[i] shouldNotBe between(afterLeft[i], afterRight[i], 0.0)63            }64            it("should clamp") {65                val mapped = beforeVal.map(beforeLeft, beforeRight,66                    afterLeft, afterRight, true)67                for (i in 0 until 2)68                    mapped[i] shouldBe between(afterLeft[i], afterRight[i], 0.0)69            }70        }71        describe("Mapping Vector3") {72            val beforeLeft = Vector3.ZERO73            val beforeRight = Vector3.ONE74            val beforeVal = beforeRight * 2.0 // out of range75            val afterLeft = Vector3.ZERO76            val afterRight = beforeRight * 2.077            it("should not clamp") {78                val mapped = beforeVal.map(beforeLeft, beforeRight,79                    afterLeft, afterRight)80                for (i in 0 until 3)81                    mapped[i] shouldNotBe between(afterLeft[i], afterRight[i], 0.0)82            }83            it("should clamp") {84                val mapped = beforeVal.map(beforeLeft, beforeRight,85                    afterLeft, afterRight, true)86                for (i in 0 until 3)87                    mapped[i] shouldBe between(afterLeft[i], afterRight[i], 0.0)88            }89        }90        describe("Mapping Vector4") {91            val beforeLeft = Vector4.ZERO92            val beforeRight = Vector4.ONE93            val beforeVal = beforeRight * 2.0 // out of range94            val afterLeft = Vector4.ZERO95            val afterRight = beforeRight * 2.096            it("should not clamp") {97                val mapped = beforeVal.map(beforeLeft, beforeRight,98                    afterLeft, afterRight)99                for (i in 0 until 4)100                    mapped[i] shouldNotBe between(afterLeft[i], afterRight[i], 0.0)101            }102            it("should clamp") {103                val mapped = beforeVal.map(beforeLeft, beforeRight,104                    afterLeft, afterRight, true)105                for (i in 0 until 4)106                    mapped[i] shouldBe between(afterLeft[i], afterRight[i], 0.0)107            }108        }109    }110    @Test111    fun shouldDoMixingOperations() {112        describe("Mixing double") {113            it("should produce expected result") {114                mix(1.0, 3.0, 0.5) shouldBe (2.0 plusOrMinus 10E-6)115                mix(3.0, 1.0, 0.5) shouldBe (2.0 plusOrMinus 10E-6)116            }117        }118        describe("Mixing angles") {119            it("should interpolate via shortest side") {120                mixAngle(5.0, 355.0, 0.5) shouldBe (0.0 plusOrMinus  10E-6)121                mixAngle(355.0, 5.0, 0.5) shouldBe (0.0 plusOrMinus  10E-6)122                mixAngle(-100.0, 100.0, 0.5).absoluteValue shouldBe (180.0 plusOrMinus  10E-6)123                mixAngle(100.0, -100.0, 0.5).absoluteValue shouldBe (180.0 plusOrMinus  10E-6)124            }125        }126    }127}...

DoubleExactlyTest.kt

Source:DoubleExactlyTest.kt

1package com.sksamuel.kotest.matchers.doubles2import io.kotest.assertions.throwables.shouldThrow3import io.kotest.core.spec.style.FreeSpec4import io.kotest.matchers.doubles.exactly5import io.kotest.matchers.doubles.shouldBeExactly6import io.kotest.matchers.doubles.shouldNotBeExactly7import io.kotest.matchers.shouldBe8import io.kotest.matchers.shouldNotBe9import io.kotest.property.checkAll10class DoubleExactlyTest : FreeSpec() {11   init {12      "for every numeric Double" - {13         "Should be exactly itself" {14            checkAll(100, numericDoubles) {15               it shouldExactlyMatch it16            }17         }18         "Should not be exactly" - {19            "Any number smaller than itself" {20               checkAll(100, nonMinNorMaxValueDoubles) {21                  it shouldNotMatchExactly it.slightlySmaller()22               }23            }...

Tolerance.kt

Source:Tolerance.kt

1package io.kotest.matchers.doubles2import io.kotest.matchers.Matcher3import io.kotest.matchers.MatcherResult4import io.kotest.matchers.should5import io.kotest.matchers.shouldNot6import kotlin.math.abs7/**8 * Creates a matcher for the interval [[this] - [tolerance] , [this] + [tolerance]]9 *10 *11 * ```12 * 0.1 shouldBe (0.4 plusOrMinus 0.5)   // Assertion passes13 * 0.1 shouldBe (0.4 plusOrMinus 0.2)   // Assertion fails14 * ```15 */16infix fun Double.plusOrMinus(tolerance: Double): ToleranceMatcher {17   require(tolerance >= 0 && tolerance.isFinite())18   return ToleranceMatcher(this, tolerance)19}20val Number.percent get() = toDouble().percent21val Double.percent: Percentage22get() {23   require(this >= 0 && this.isFinite())24   return Percentage(this)25}26data class Percentage(val value: Double)27/**28 * Creates a matcher for the interval [[this] - [tolerance] , [this] + [tolerance]]29 *30 *31 * ```32 * 1.5 shouldBe (1.0 plusOrMinus 50.percent )   // Assertion passes33 * 1.5 shouldBe (1.0 plusOrMinus 10.percent)   // Assertion fails34 * ```35 */36infix fun Double.plusOrMinus(tolerance: Percentage): ToleranceMatcher {37   val realValue = this * tolerance.value / 10038   return ToleranceMatcher(this, realValue)39}40class ToleranceMatcher(private val expected: Double?, private val tolerance: Double) : Matcher<Double?> {41  override fun test(value: Double?): MatcherResult {42    return if (value == null || expected == null || expected.isInfinite()) {43       MatcherResult(44          value == expected,45          { "$value should be equal to $expected" },46          {47             "$value should not be equal to $expected"48          })49    } else if (expected.isNaN() && value.isNaN()) {50       println("[WARN] By design, Double.Nan != Double.Nan; see https://stackoverflow.com/questions/8819738/why-does-double-nan-double-nan-return-false/8819776#8819776")51       MatcherResult(52          false,53          { "By design, Double.Nan != Double.Nan; see https://stackoverflow.com/questions/8819738/why-does-double-nan-double-nan-return-false/8819776#8819776" },54          {55             "By design, Double.Nan != Double.Nan; see https://stackoverflow.com/questions/8819738/why-does-double-nan-double-nan-return-false/8819776#8819776"56          })57    } else {58       if (tolerance == 0.0)59          println("[WARN] When comparing doubles consider using tolerance, eg: a shouldBe (b plusOrMinus c)")60       val diff = abs(value - expected)61       val passed = diff <= tolerance62       val low = expected - tolerance63       val high = expected + tolerance64       val msg = when (tolerance) {65          0.0 -> "$value should be equal to $expected"66          else -> "$value should be equal to $expected within tolerance of $tolerance (lowest acceptable value is $low; highest acceptable value is $high)"67       }68       MatcherResult(69          passed,70          { msg },71          { "$value should not be equal to $expected" })72    }73  }74}75/**76 * Verifies that this double is within [percentage]% of [other]77 *78 * 90.0.shouldBeWithinPercentageOf(100.0, 10.0)  // Passes79 * 50.0.shouldBeWithinPercentageOf(100.0, 50.0)  // Passes80 * 30.0.shouldBeWithinPercentageOf(100.0, 10.0)  // Fail81 *82 */83fun Double.shouldBeWithinPercentageOf(other: Double, percentage: Double) {84   require(percentage > 0.0) { "Percentage must be > 0.0" }85   this should beWithinPercentageOf(other, percentage)86}87/**88 * Verifies that this double is NOT within [percentage]% of [other]89 *90 * 90.0.shouldNotBeWithinPercentageOf(100.0, 10.0)  // Fail91 * 50.0.shouldNotBeWithinPercentageOf(100.0, 50.0)  // Fail92 * 30.0.shouldNotBeWithinPercentageOf(100.0, 10.0)  // Passes93 *94 */95fun Double.shouldNotBeWithinPercentageOf(other: Double, percentage: Double) {96   require(percentage > 0.0) { "Percentage must be > 0.0" }97   this shouldNot beWithinPercentageOf(other, percentage)98}99fun beWithinPercentageOf(other: Double, percentage: Double) = object : Matcher<Double> {100   private val tolerance = other.times(percentage / 100)101   private val range = (other - tolerance)..(other + tolerance)102   override fun test(value: Double) = MatcherResult(103      value in range,104      { "$value should be in $range" },105      {106         "$value should not be in $range"107      })108}...

FloatNaNTest.kt

Source:FloatNaNTest.kt

1package com.sksamuel.kotest.matchers.floats2import com.sksamuel.kotest.matchers.doubles.numericFloats3import io.kotest.assertions.throwables.shouldThrow4import io.kotest.core.spec.style.FunSpec5import io.kotest.matchers.floats.beNaN6import io.kotest.matchers.floats.shouldBeNaN7import io.kotest.matchers.floats.shouldNotBeNaN8import io.kotest.matchers.should9import io.kotest.matchers.shouldBe10import io.kotest.matchers.shouldNot11import io.kotest.property.checkAll12class FloatNaNTest : FunSpec() {13   init {14      context("NaN matcher") {15         test("Every numeric float should not be NaN") {16            checkAll(100, numericFloats) {17               it.shouldNotMatchNaN()18            }19         }20         test("The non-numeric floats") {21            Float.NaN.shouldMatchNaN()22            Float.POSITIVE_INFINITY.shouldNotMatchNaN()23            Float.NEGATIVE_INFINITY.shouldNotMatchNaN()24         }25      }26   }27   private fun Float.shouldMatchNaN() {28      this should beNaN()29      this.shouldBeNaN()30      this.shouldThrowExceptionOnNotBeNaN()31   }32   private fun Float.shouldNotMatchNaN() {33      this shouldNot beNaN()34      this.shouldNotBeNaN()...

NaN.kt

Source:NaN.kt

1package io.kotest.matchers.doubles2import io.kotest.matchers.Matcher3import io.kotest.matchers.MatcherResult4import io.kotest.matchers.should5import io.kotest.matchers.shouldNot6/**7 * Asserts that this [Double] is [Double.NaN]8 *9 * Verifies that this [Double] is the Not-a-Number constant [Double.NaN]10 *11 * Opposite of [shouldNotBeNaN]12 *13 * ```14 * Double.NaN.shouldBeNaN()   // Assertion passes15 * 1.0.shouldBeNaN()          // Assertion fails16 * ```17 * @see [beNaN]18 */19fun Double.shouldBeNaN() = this should beNaN()20/**21 * Assert that this [Double] is not [Double.NaN]22 *23 * Verifies that this [Double] is NOT the Not-a-Number constant [Double.NaN]24 *25 * Opposite of [shouldBeNaN]26 *27 * ```28 * 1.0.shouldNotBeNaN()         // Assertion passes29 * Double.NaN.shouldNotBeNaN()  // Assertion fails30 * ```31 * @see [beNaN]32 */33fun Double.shouldNotBeNaN() = this shouldNot beNaN()34/**35 * Matcher that matches [Double.NaN]36 *37 * Verifies that a specific [Double] is the Not-a-Number constant [Double.NaN]38 *39 * ```40 *  0.5 should beNaN()            // Assertion fails41 *  Double.NaN should beNaN()     // Assertion passes42 * ```43 *44 * @see [Double.shouldBeNaN]45 * @see [Double.shouldNotBeNaN]46 */47fun beNaN() = object : Matcher<Double> {48  override fun test(value: Double) = MatcherResult(49    value.isNaN(),50    "$value should be NaN",51    "$value should not be NaN"52  )53}...

EpsilonTest.kt

Source:EpsilonTest.kt

...5 *  * Please check the file copyright.txt in the root of the source for further details.6 *7 */8package com.radixpro.enigma.libbe.astron9import io.kotest.matchers.doubles.plusOrMinus10import io.kotest.matchers.shouldBe11import org.junit.jupiter.api.Test12import swisseph.SwissEph13private const val margin = 0.0000000114internal class EpsilonTest {15    @Test16    fun `calculation of true obliquity shoud return correct result`() {17        val swissEph = SwissEph()18        val epsilon = Epsilon(swissEph)19        val jdUt = 2434406.817713       // 1953-1-29 UT 7:3720        val expected = 23.447072302721        epsilon.calcTrueEpsilon(jdUt).first shouldBe(expected plusOrMinus margin)22        epsilon.calcTrueEpsilon(jdUt).second shouldBe("")23    }24    @Test...

test

Using AI Code Generation

1+import io.kotest.matchers.doubles.NaN2+import io.kotest.matchers.doubles.isFinite3+import io.kotest.matchers.doubles.isInfinite4+import io.kotest.matchers.doubles.isNaN5+import io.kotest.matchers.doubles.isNegativeInfinity6+import io.kotest.matchers.doubles.isPositiveInfinity7+import io.kotest.matchers.doubles.isZero8+import io.kotest.matchers.doubles.shouldBeFinite9+import io.kotest.matchers.doubles.shouldBeInfinite10+import io.kotest.matchers.doubles.shouldBeNaN11+import io.kotest.matchers.doubles.shouldBeNegativeInfinity12+import io.kotest.matchers.doubles.shouldBePositiveInfinity13+import io.kotest.matchers.doubles.shouldBeZero14+import io.kotest.matchers.doubles.shouldNotBeFinite

test

Using AI Code Generation

1    fun `test method of io.kotest.matchers.doubles.NaN class`(){2    }3    fun `test method of io.kotest.matchers.doubles.NaN class`(){4    }5    fun `test method of io.kotest.matchers.doubles.NaN class`(){6    }7    fun `test method of io.kotest.matchers.doubles.NaN class`(){8    }9    fun `test method of io.kotest.matchers.doubles.NaN class`(){10    }11    fun `test method of io.kotest.matchers.doubles.NaN class`(){12    }13    fun `test method of io.kotest.matchers.doubles.NaN class`(){14    }15    fun `test method of io.kotest.matchers.doubles.NaN class`(){16    }17    fun `test method of io.kotest.matchers.doubles.NaN class`(){18    }

test

Using AI Code Generation

1        nan.test(0.0/0.0) shouldBe true2        nan.test(1.0) shouldBe false3    }4    fun testNaN2() {5        nan.test(0.0/0.0) shouldBe true6        nan.test(1.0) shouldBe false7    }8    fun testNaN3() {9        nan.test(0.0/0.0) shouldBe true10        nan.test(1.0) shouldBe false11    }12    fun testNaN4() {13        nan.test(0.0/0.0) shouldBe true14        nan.test(1.0) shouldBe false15    }16    fun testNaN5() {17        nan.test(0.0/0.0) shouldBe true18        nan.test(1.0) shouldBe false19    }20    fun testNaN6() {21        nan.test(0.0/0.0) shouldBe true22        nan.test(1.0) shouldBe false23    }24    fun testNaN7() {25        nan.test(0.0/0.0) shouldBe true26        nan.test(1.0) shouldBe false27    }28    fun testNaN8() {29        nan.test(0.0/0.0) shouldBe true30        nan.test(1.0) shouldBe false31    }32    fun testNaN9() {

test

Using AI Code Generation

1	fun testNaN() {2		(0.0 / 0.0).should(beNaN())3	}4	fun testIsFinite() {5		(0.0 / 0.0).shouldNot(beFinite())6	}7	fun testIsInfinite() {8		(0.0 / 0.0).should(beInfinite())9	}10	fun testIsPositiveInfinity() {11		(1.0 / 0.0).should(bePositiveInfinity())12	}13	fun testIsNegativeInfinity() {14		(-1.0 / 0.0).should(beNegativeInfinity())15	}16	fun testIsZero() {17		(0.0).should(beZero())18	}19	fun testIsNotZero() {20		(1.0).shouldNot(beZero())21	}22	fun testIsPositive() {23		(1.0).should(bePositive())24	}

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.