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

Copied to Clipboard!

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

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

FixedBigRationalTest.kt

Source:FixedBigRationalTest.kt

1package hm.binkley.math.fixed2import hm.binkley.math.BFixed3import hm.binkley.math.BFloating4import hm.binkley.math.big5import hm.binkley.math.compareTo6import hm.binkley.math.fixed.FixedBigRational.Companion.ONE7import hm.binkley.math.fixed.FixedBigRational.Companion.TEN8import 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`() {34            (ONE..TEN).equals(this).shouldBeFalse()35            (ONE..TEN) shouldNotBe36                FloatingBigRational.ONE..FloatingBigRational.TEN37            (ONE..TEN).hashCode() shouldNotBe38                (FloatingBigRational.ONE..FloatingBigRational.TEN).hashCode()39        }40    }41    @Nested42    inner class ConversionTests {43        @Test44        fun `should convert BigDecimal in infix constructor`() {45            0.0.big.toBigRational() shouldBe ZERO46            30.0.big.toBigRational() shouldBe (30 over 1)47            3.0.big.toBigRational() shouldBe (3 over 1)48            BFloating("0.3").toBigRational() shouldBe (3 over 10)49            BFloating("7.70").toBigRational() shouldBe (77 over 10)50            (1.0.big over 1.0.big) shouldBe ONE51            (1.big over 1.0.big) shouldBe ONE52            (1L over 1.0.big) shouldBe ONE53            (1 over 1.0.big) shouldBe ONE54            (1.0 over 1.0.big) shouldBe ONE55            (1.0f over 1.0.big) shouldBe ONE56            (1.0.big over 1L) shouldBe ONE57            (1.0.big over 1) shouldBe ONE58        }59        @Test60        fun `should convert BigInteger in infix constructor`() {61            0.big.toBigRational() shouldBe ZERO62            BFixed.valueOf(30L).toBigRational() shouldBe (30 over 1)63            3.big.toBigRational() shouldBe (3 over 1)64            (1.big over 1.big) shouldBe ONE65            (1.0.big over 1.big) shouldBe ONE66            (1L over 1.big) shouldBe ONE67            (1 over 1.big) shouldBe ONE68            (1.0 over 1.big) shouldBe ONE69            (1.0f over 1.big) shouldBe ONE70            (1.big over 1L) shouldBe ONE71            (1.big over 1) shouldBe ONE72        }73        @Test74        fun `should convert double in infix constructor`() {75            (1.0.big over 1.0) shouldBe ONE76            (1.big over 1.0) shouldBe ONE77            (1L over 1.0) shouldBe ONE78            (1 over 1.0) shouldBe ONE79            (1.0 over 1.0) shouldBe ONE80            (1.0f over 1.0) shouldBe ONE81            (1.0 over 1.big) shouldBe ONE82            (1.0 over 1L) shouldBe ONE83            (1.0 over 1) shouldBe ONE84        }85        @Test86        fun `should not convert non-finite doubles`() {87            shouldThrow<ArithmeticException> {88                valueOf(Double.NaN)89            }90            shouldThrow<ArithmeticException> {91                valueOf(Double.POSITIVE_INFINITY)92            }93            shouldThrow<ArithmeticException> {94                valueOf(Double.NEGATIVE_INFINITY)95            }96        }97        @Test98        fun `should convert float in infix constructor`() {99            (1.0.big over 1.0f) shouldBe ONE100            (1.big over 1.0f) shouldBe ONE101            (1L over 1.0f) shouldBe ONE102            (1 over 1.0f) shouldBe ONE103            (1.0 over 1.0f) shouldBe ONE104            (1.0f over 1.0f) shouldBe ONE105            (1.0f over 1.big) shouldBe ONE106            (1.0f over 1L) shouldBe ONE107            (1.0f over 1) shouldBe ONE108        }109        @Test110        fun `should convert integral types in infix constructor`() {111            (1L over 1) shouldBe ONE112            (1 over 1L) shouldBe ONE113        }114        @Test115        fun `should convert to and from big decimal`() {116            val decimals = listOf(117                -4.0,118                -3.0,119                -2.0,120                -1.0,121                -0.5,122                -0.3,123                -0.1,124                0.0,125                0.1,126                0.3,127                0.5,128                1.0,129                2.0,130                3.0,131                4.0,132                123.456133            ).map { it.toBigDecimal() }134            val rationals = listOf(135                -4 over 1,136                -3 over 1,137                -2 over 1,138                -1 over 1,139                -1 over 2,140                -3 over 10,141                -1 over 10,142                ZERO,143                1 over 10,144                3 over 10,145                1 over 2,146                ONE,147                2 over 1,148                3 over 1,149                4 over 1,150                15432 over 125151            )152            decimals.map {153                it.toBigRational()154            } shouldBe rationals155            rationals.map {156                it.toBigDecimal()157            } shouldBe decimals158        }159        @Test160        fun `should convert to and from double`() {161            val doubles = listOf(162                -4.0,163                -3.0,164                -2.0,165                -1.0,166                -0.5,167                -0.3,168                -0.1,169                0.0,170                0.1,171                0.3,172                0.5,173                1.0,174                2.0,175                3.0,176                4.0,177                123.456178            )179            val rationals = listOf(180                -4 over 1,181                -3 over 1,182                -2 over 1,183                -1 over 1,184                -1 over 2,185                -3 over 10,186                -1 over 10,187                ZERO,188                1 over 10,189                3 over 10,190                1 over 2,191                ONE,192                2 over 1,193                3 over 1,194                4 over 1,195                15432 over 125196            )197            doubles.map {198                it.toBigRational()199            } shouldBe rationals200            rationals.map {201                it.toDouble()202            } shouldBe doubles203        }204        @Test205        fun `should convert to and from float`() {206            val floats = listOf(207                -4.0f,208                -3.0f,209                -2.0f,210                -1.0f,211                -0.5f,212                -0.3f,213                -0.1f,214                0.0f,215                0.1f,216                0.3f,217                0.5f,218                1.0f,219                2.0f,220                3.0f,221                4.0f,222                123.456f223            )224            val rationals = listOf(225                -4 over 1,226                -3 over 1,227                -2 over 1,228                -1 over 1,229                -1 over 2,230                -3 over 10,231                -1 over 10,232                ZERO,233                1 over 10,234                3 over 10,235                1 over 2,236                ONE,237                2 over 1,238                3 over 1,239                4 over 1,240                15432 over 125241            )242            floats.map {243                it.toBigRational()244            } shouldBe rationals245            rationals.map {246                it.toFloat()247            } shouldBe floats248        }249        @Test250        fun `should convert to floating equivalent`() {251            ONE.toFloatingBigRational() shouldBe FloatingBigRational.ONE252        }253    }254    @Nested255    inner class FunctionTests {256        @Test257        fun `should compare other number types`() {258            shouldThrow<ArithmeticException> {259                Double.POSITIVE_INFINITY > ZERO260            }261            shouldThrow<ArithmeticException> {262                ZERO < Double.POSITIVE_INFINITY263            }264            shouldThrow<ArithmeticException> {265                ZERO > Double.NEGATIVE_INFINITY266            }267            shouldThrow<ArithmeticException> {268                Double.NEGATIVE_INFINITY < ZERO269            }270            shouldThrow<ArithmeticException> {271                Float.NaN > ZERO272            }273            shouldThrow<ArithmeticException> {274                ZERO < Float.NaN275            }276        }277        @Test278        fun `should multiplicatively invert`() {279            shouldThrow<ArithmeticException> {280                ZERO.unaryDiv()281            }282        }283    }284}...

CylinderTest.kt

Source:CylinderTest.kt

...3import io.github.ocirne.ray.challenge.raysphere.Ray4import io.github.ocirne.ray.challenge.shapes.Cylinder5import io.github.ocirne.ray.challenge.tuples.*6import io.kotest.matchers.collections.beEmpty7import io.kotest.matchers.doubles.beNegativeInfinity8import io.kotest.matchers.doubles.bePositiveInfinity9import io.kotest.matchers.should10import io.kotest.matchers.shouldBe11import org.junit.jupiter.api.Test12import org.junit.jupiter.api.TestInstance13import org.junit.jupiter.params.ParameterizedTest14import org.junit.jupiter.params.provider.MethodSource15@TestInstance(TestInstance.Lifecycle.PER_CLASS)16internal class CylinderTest {17    data class ExampleRayMisses(val origin: Point, val direction: Vector)18    fun examplesRayMisses() = listOf(19        ExampleRayMisses(point(1, 0, 0), vector(0, 1, 0)),20        ExampleRayMisses(point(0, 0, 0), vector(0, 1, 0)),21        ExampleRayMisses(point(0, 0, -5), vector(1, 1, 1))22    )23    @ParameterizedTest24    @MethodSource("examplesRayMisses")25    fun `Scenario Outline A ray misses a Cylinder`(ex: ExampleRayMisses) {26        val cyl = Cylinder()27        val direction = ex.direction.normalize()28        val r = Ray(ex.origin, direction)29        val xs = cyl.localIntersect(r)30        xs should beEmpty()31    }32    data class ExampleRayStrikes(val origin: Point, val direction: Vector, val t0: Double, val t1: Double)33    fun examplesRayStrikes() = listOf(34        ExampleRayStrikes(point(1, 0, -5), vector(0, 0, 1), 5.0, 5.0),35        ExampleRayStrikes(point(0, 0, -5), vector(0, 0, 1), 4.0, 6.0),36        ExampleRayStrikes(point(0.5, 0.0, -5.0), vector(0.1, 1.0, 1.0), 6.80798, 7.08872)37    )38    @ParameterizedTest39    @MethodSource("examplesRayStrikes")40    fun `Scenario Outline A ray strikes a Cylinder`(ex: ExampleRayStrikes) {41        val cyl = Cylinder()42        val direction = ex.direction.normalize()43        val r = Ray(ex.origin, direction)44        val xs = cyl.localIntersect(r)45        xs.size shouldBe 246        xs[0].t.equalsDelta(ex.t0) shouldBe true47        xs[1].t.equalsDelta(ex.t1) shouldBe true48    }49    data class ExampleNormalVector(val point: Point, val normal: Vector)50    fun examplesNormalVector() = listOf(51        ExampleNormalVector(point(1, 0, 0), vector(1, 0, 0)),52        ExampleNormalVector(point(0, 5, -1), vector(0, 0, -1)),53        ExampleNormalVector(point(0, -2, 1), vector(0, 0, 1)),54        ExampleNormalVector(point(-1, 1, 0), vector(-1, 0, 0))55    )56    @ParameterizedTest57    @MethodSource("examplesNormalVector")58    fun `Scenario Outline Normal vector on a Cylinder`(ex: ExampleNormalVector) {59        val cyl = Cylinder()60        val n = cyl.localNormalAt(ex.point)61        n shouldBe ex.normal62    }63    @Test64    fun `Scenario The default minimum and maximum for a Cylinder`() {65        val cyl = Cylinder()66        cyl.minimum should beNegativeInfinity()67        cyl.maximum should bePositiveInfinity()68    }69    data class ExampleIntersectingConstrained(val number: Int, val point: Point, val direction: Vector, val count: Int)70    fun examplesIntersectingConstrained() = listOf(71        ExampleIntersectingConstrained(1, point(0.0, 1.5, 0.0), vector(0.1, 1.0, 0.0), 0),72        ExampleIntersectingConstrained(2, point(0, 3, -5), vector(0, 0, 1), 0),73        ExampleIntersectingConstrained(3, point(0, 0, -5), vector(0, 0, 1), 0),74        ExampleIntersectingConstrained(4, point(0, 2, -5), vector(0, 0, 1), 0),75        ExampleIntersectingConstrained(5, point(0, 1, -5), vector(0, 0, 1), 0),76        ExampleIntersectingConstrained(6, point(0.0, 1.5, -2.0), vector(0, 0, 1), 2)77    )78    @ParameterizedTest79    @MethodSource("examplesIntersectingConstrained")80    fun `Scenario Outline Intersecting a constrained Cylinder`(ex: ExampleIntersectingConstrained) {81        val cyl = Cylinder(minimum = 1.0, maximum = 2.0)...

DoubleExactlyTest.kt

Source:DoubleExactlyTest.kt

...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.NaN70               }71            }72         }73         "Negative Infinity" - {74            "Should be exactly" - {75               "Itself" {76                  Double.Companion.NEGATIVE_INFINITY shouldExactlyMatch Double.Companion.NEGATIVE_INFINITY77               }78            }79            "Should not be exactly" - {80               "Any numeric double" {81                  checkAll(100, numericDoubles) {82                     Double.NEGATIVE_INFINITY shouldNotMatchExactly it83                  }84               }85               "Any other non-numeric double" {86                  Double.Companion.NEGATIVE_INFINITY shouldNotMatchExactly Double.Companion.POSITIVE_INFINITY87                  Double.Companion.NEGATIVE_INFINITY shouldNotMatchExactly Double.Companion.NaN...

DoubleNumberTests.kt

Source:DoubleNumberTests.kt

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 Ð½Ðµ Ð¿Ð¾Ð»Ð¾Ð¶Ð¸ÑÐµÐ»ÑÐ½Ð¾" {...

DoubleToleranceTest.kt

Source:DoubleToleranceTest.kt

1package com.sksamuel.kotest.matchers.doubles2import io.kotest.assertions.throwables.shouldThrow3import io.kotest.assertions.throwables.shouldThrowAny4import io.kotest.core.spec.style.FunSpec5import io.kotest.matchers.doubles.percent6import io.kotest.matchers.doubles.plusOrMinus7import io.kotest.matchers.doubles.shouldBeWithinPercentageOf8import io.kotest.matchers.shouldBe9import io.kotest.matchers.shouldNotBe10import io.kotest.property.Arb11import io.kotest.property.arbitrary.bind12import io.kotest.property.arbitrary.double13import io.kotest.property.arbitrary.numericDouble14import io.kotest.property.checkAll15class DoubleToleranceTest : FunSpec({16   test("double with tolerance should include tolerance in error message") {17      shouldThrowAny {18         1.0 shouldBe (1.5 plusOrMinus 0.4)19      }.message shouldBe "1.0 should be equal to 1.5 within tolerance of 0.4 (lowest acceptable value is 1.1; highest acceptable value is 1.9)"20   }21   test("infinite double with finite tolerance should equal the same infinite double") {22      checkAll(Arb.numericDouble(min = 0.0)) { eps ->23         Double.NEGATIVE_INFINITY shouldBe (Double.NEGATIVE_INFINITY plusOrMinus eps)24         Double.POSITIVE_INFINITY shouldBe (Double.POSITIVE_INFINITY plusOrMinus eps)25      }26   }27   test("Allow for percentage tolerance") {28      1.5 shouldBe (1.0 plusOrMinus 50.percent)29      1.5 shouldNotBe (2.0 plusOrMinus 10.percent)30   }31   context("Percentage") {32      test("Match equal numbers") {33         Arb.bind(Arb.double(), Arb.double(0.0, 5.0)) { value, percentage ->34            value.shouldBeWithinPercentageOf(value, percentage)35         }36      }37      test("Refuse negative percentage") {38         shouldThrow<IllegalArgumentException> {39            1.0.shouldBeWithinPercentageOf(1.0, -0.1)40         }41      }42      test("Match close enough numbers") {43         Arb.bind(Arb.double(), Arb.double(0.0, 5.0)) { value, percentage ->44            value.shouldBeWithinPercentageOf((value - value.times(percentage / 100)), percentage)45            value.shouldBeWithinPercentageOf((value + value.times(percentage / 100)), percentage)46         }47      }48   }49})...

BmiEnglishUnitsTest.kt

Source:BmiEnglishUnitsTest.kt

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

BmiMetricTest.kt

Source:BmiMetricTest.kt

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

arbs.kt

Source:arbs.kt

1package com.sksamuel.kotest.matchers.doubles2import io.kotest.property.Arb3import io.kotest.property.arbitrary.double4import io.kotest.property.arbitrary.filterNot5import io.kotest.property.arbitrary.float6val nonNumericDoubles = listOf(Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY)7val numericDoubles = Arb.double().filterNot { it in nonNumericDoubles }8val nonMinNorMaxValueDoubles = numericDoubles.filterNot { it in listOf(Double.MAX_VALUE, Double.MIN_VALUE) }9val nonNumericFloats = listOf(Float.NaN, Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY)10val numericFloats = Arb.float().filterNot { it in nonNumericFloats }...

Infinity

Using AI Code Generation

1    import io.kotest.matchers.doubles.*2    import io.kotest.matchers.longs.*3    import io.kotest.matchers.shorts.*4fun main(args: Array<String>) {5    println(positiveInfinity.isPositiveInfinity)6}7fun main(args: Array<String>) {8    println(negativeInfinity.isNegativeInfinity)9}

Infinity

Using AI Code Generation

1    import io.kotest.matchers.doubles.*2    import io.kotest.matchers.longs.*3    import io.kotest.matchers.ints.*4    import io.kotest.matchers.bytes.*5    import io.kotest.matchers.shorts.*6    import io.kotest.matchers.floats.*7    import io.kotest.matchers.chars.*8    import io.kotest.matchers.durations.*9    import io.kotest.matchers.longs.*10    import io.kotest.matchers.doubles.*11    import io.kotest.matchers.floats.*12    import io.kotest.matchers.bytes.*13    import io.kotest.matchers.shorts.*14    import io.kotest.matchers.ints.*15    import io.kotest.matchers.chars.*16    import io.kotest.matchers.durations.*17    import io.kotest.matchers.longs.*18    import io

Infinity

Using AI Code Generation

1    import io.kotest.matchers.doubles.*2    import io.kotest.matchers.*3    import io.kotest.matchers.string.*4    import io.kotest.matchers.*5    import io.kotest.matchers.string.*6    import io.kotest.matchers.*7    import io.kotest.matchers.string.*8    import io.kotest.matchers.*9    import io.kotest.matchers.string.*10    import io.kotest.matchers.*11    import io.kotest.matchers.string.*12    import io.kotest.matchers.*13    import io.kotest.matchers.string.*14    import io.kotest.matchers.*15    import io.kotest.matchers.string.*16    import io.kotest.matchers.*17    import io.kotest.matchers.string.*18    import io.kotest.matchers.*19    import io.kotest.matchers.string.*

Infinity

Using AI Code Generation

1x.shouldBeNaN()2x.shouldBePositiveInfinity()3x.shouldBeNegativeInfinity()4x.shouldBeInfinite()5x.shouldBeNotInfinite()6x.shouldBeNotNaN()7x.shouldBeNotFinite()8x.shouldBeFinite()9x.shouldBeNormal()10x.shouldBeSubnormal()11x.shouldBeNotSubnormal()12x.shouldBeNotNormal()13x.shouldBeNotZero()14x.shouldBeZero()

Infinity

Using AI Code Generation

1import io.kotest.matchers.doubles.*2import io.kotest.matchers.longs.*3import io.kotest.matchers.nulls.*4a shouldBeNull()5a shouldNotBeNull()6import io.kotest.matchers.reflection.*

Infinity

Using AI Code Generation

1a shouldBe b.plusOrMinus(0.1)2a shouldBe b.plusOrMinus(0.01)3a shouldBe b.plusOrMinus(0.001)4a shouldBe b.plusOrMinus(0.0001)5a shouldBe b.plusOrMinus(0.00001)6a shouldBe b.plusOrMinus(0.000001)7a shouldBe b.plusOrMinus(0.0000001)8a shouldBe b.plusOrMinus(0.00000001)9a shouldBe b.plusOrMinus(0.000000001)10a shouldBe b.plusOrMinus(0.0000000001)11a shouldBe b.plusOrMinus(0.00000000001)12a shouldBe b.plusOrMinus(0.000000000001)13a shouldBe b.plusOrMinus(0.0000000000001)14a shouldBe b.plusOrMinus(0.00000000000001)15a shouldBe b.plusOrMinus(0.000000000000001)16a shouldBe b.plusOrMinus(0.0000000000000001)17a shouldBe b.plusOrMinus(0.00000000000000001)18a shouldBe b.plusOrMinus(0.000000000000000001)19a shouldBe b.plusOrMinus(0.0000000000000000001)20a shouldBe b.plusOrMinus(0.00000000000000000001)21a shouldBe b.plusOrMinus(0.000000000000000000001)22a shouldBe b.plusOrMinus(0.0000000000000000000001)23a shouldBe b.plusOrMinus(0.00000000000000000000001)24a shouldBe b.plusOrMinus(0.000000000000000000000001)25a shouldBe b.plusOrMinus(0.0000000000000000000000001)26a shouldBe b.plusOrMinus(0.00000000000000000000000001)27a shouldBe b.plusOrMinus(0.000000000000000000000000001)28a shouldBe b.plusOrMinus(0.0000000000000000000000000001)29a shouldBe b.plusOrMinus(0.00000000000000000000000000001)30a shouldBe b.plusOrMinus(0.000000000000000000000000000001)31a shouldBe b.plusOrMinus(

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.