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

Copied to Clipboard!

How to use Int.shouldBeNegative method of io.kotest.matchers.ints.int class

Best Kotest code snippet using io.kotest.matchers.ints.int.Int.shouldBeNegative

AssertSoftlyTest.kt

Source:AssertSoftlyTest.kt

1package com.sksamuel.kotest.matchers2import io.kotest.assertions.assertSoftly3import io.kotest.assertions.throwables.shouldThrow4import io.kotest.assertions.withClue5import io.kotest.core.spec.style.FreeSpec6import io.kotest.matchers.collections.containExactly7import io.kotest.matchers.comparables.beLessThan8import io.kotest.matchers.doubles.negative9import io.kotest.matchers.doubles.positive10import io.kotest.matchers.doubles.shouldBeNegative11import io.kotest.matchers.ints.shouldBeLessThan12import io.kotest.matchers.ints.shouldBePositive13import io.kotest.matchers.maps.haveKey14import io.kotest.matchers.should15import io.kotest.matchers.shouldBe16import io.kotest.matchers.shouldNot17import io.kotest.matchers.shouldNotBe18import io.kotest.matchers.string.contain19import io.kotest.matchers.string.endWith20import io.kotest.matchers.string.shouldContain21import io.kotest.matchers.string.shouldNotContain22import io.kotest.matchers.string.shouldNotEndWith23import io.kotest.matchers.string.shouldStartWith24class AssertSoftlyTest : FreeSpec({25   "assertSoftly" - {26      "passes when all assertions pass" {27         assertSoftly {28            1 shouldBe 129            "foo" shouldBe "foo"30         }31      }32      "rethrows single failures" {33         val exception = shouldThrow<AssertionError> {34            assertSoftly {35               1 shouldBe 236            }37         }38         exception.message shouldBe "expected:<2> but was:<1>"39         exception.stackTrace.first().className shouldStartWith "com.sksamuel.kotest.matchers.AssertSoftlyTest"40      }41      "groups multiple failures" {42         shouldThrow<AssertionError> {43            assertSoftly {44               1 shouldBe 245               1 shouldBe 1 // should pass46               "foo" shouldNotBe "foo"47            }48         }.let {49            it.message should contain("1) expected:<2> but was:<1>")50            it.message should contain("2) \"foo\" should not equal \"foo\"")51            it.stackTrace.first().className shouldStartWith "com.sksamuel.kotest.matchers.AssertSoftlyTest"52         }53      }54      "works with all array types" {55         shouldThrow<AssertionError> {56            assertSoftly {57               booleanArrayOf(true) shouldBe booleanArrayOf(false)58               intArrayOf(1) shouldBe intArrayOf(2)59               shortArrayOf(1) shouldBe shortArrayOf(2)60               floatArrayOf(1f) shouldBe floatArrayOf(2f)61               doubleArrayOf(1.0) shouldBe doubleArrayOf(2.0)62               longArrayOf(1) shouldBe longArrayOf(2)63               byteArrayOf(1) shouldBe byteArrayOf(2)64               charArrayOf('a') shouldBe charArrayOf('b')65               arrayOf("foo") shouldBe arrayOf("bar")66            }67         }.let {68            it.message should contain("1) expected:<[false]> but was:<[true]>")69            it.message should contain("2) expected:<[2]> but was:<[1]>")70            it.message should contain("3) expected:<[2]> but was:<[1]>")71            it.message should contain("4) expected:<[2.0f]> but was:<[1.0f]>")72            it.message should contain("5) expected:<[2.0]> but was:<[1.0]>")73            it.message should contain("6) expected:<[2L]> but was:<[1L]>")74            it.message should contain("7) expected:<[2]> but was:<[1]>")75            it.message should contain("8) expected:<['b']> but was:<['a']>")76            it.message should contain("""9) Element differ at index: [0]77                                                |expected:<["bar"]> but was:<["foo"]>""".trimMargin())78            it.message shouldNot contain("10) ")79         }80      }81      "works with any matcher" {82         shouldThrow<AssertionError> {83            assertSoftly {84               1 should beLessThan(0)85               "foobar" shouldNot endWith("bar")86               1 shouldBe positive() // should pass87               1.0 shouldBe negative()88               listOf(1) shouldNot containExactly(1)89               mapOf(1 to 2) should haveKey(3)90            }91         }.let {92            it.message should contain("5) Map should contain key 3")93            it.message shouldNot contain("6) ")94         }95      }96      "works with extension functions" {97         shouldThrow<AssertionError> {98            assertSoftly {99               1.shouldBeLessThan(0)100               "foobar".shouldNotEndWith("bar")101               1.shouldBePositive() // should pass102               1.0.shouldBeNegative()103            }104         }.let {105            it.message should contain("""1) 1 should be < 0""")106            it.message should contain("""2) "foobar" should not end with "bar"""")107            it.message should contain("""3) 1.0 should be < 0.0""")108            it.message shouldNot contain("4) ")109         }110      }111      "can be nested" {112         shouldThrow<AssertionError> {113            assertSoftly {114               1 shouldBe 2115               assertSoftly {116                  2 shouldBe 3117               }118            }119         }.let {120            it.message should contain("1) expected:<2> but was:<1>")121            it.message should contain("2) expected:<3> but was:<2>")122         }123      }124      "should not have any receiver context" {125         data class Person(val name: String, val age: Int)126         fun verifier(person: Person, assertion: (Person) -> Unit) {127            assertion(person)128         }129         val person = Person("foo", 0)130         verifier(person) {131            it shouldBe person132            assertSoftly {133               it shouldBe person // it being person verifies assertSoftly does not have any receiver134            }135         }136      }137      "Receiver version" - {138         "works on a receiver object" {139            shouldThrow<AssertionError> {140               assertSoftly("foo") {141                  length shouldBe 2142                  this[1] shouldBe 'o' // should pass143                  this shouldNotBe "foo"144               }145            }.let {146               it.message should contain("1) expected:<2> but was:<3>")147               it.message should contain("2) \"foo\" should not equal \"foo\"")148            }149         }150         "Returns the receiver" {151            val a = assertSoftly("foo") {152               this shouldNotBe "bar"153               shouldNotEndWith("abc")154            }155            a shouldBe "foo"156         }157         "works with 'it' receiver" {158            val a = assertSoftly("foo") {159               it shouldNotBe "bar"160            }161            a shouldBe "foo"162         }163         "works with my parameter name" {164            val a =165               assertSoftly("foo") { foo ->  // No idea why anybody would use this, but it's better to keep the verification that this works166                  foo shouldNotBe "bar"167               }168            a shouldBe "foo"169         }170      }171      "Assert softly with data classes" - {172         // Added as a verification of https://github.com/kotest/kotest/issues/1831173         "work with enum in data class" {174            val source = WithSimpleEnum(enumValue = SimpleEnum.First)175            val result = WithSimpleEnum(enumValue = SimpleEnum.Second)176            val error = shouldThrow<AssertionError> {177               assertSoftly {178                  withClue("simple strings") {179                     "a" shouldBe "b"180                     "a" shouldNotBe "b"181                  }182                  withClue("more complex with data class and enums") {183                     source shouldBe result184                     source shouldNotBe result185                  }186               }187            }188            error.message shouldContain "1) simple strings\n" +189               "expected:<\"b\"> but was:<\"a\">"190            error.message shouldContain "2) data class diff for com.sksamuel.kotest.matchers.WithSimpleEnum\n" +191               "â enumValue: more complex with data class and enums\n" +192               "expected:<Second> but was:<First>"193            error.message shouldNotContain "3) "194         }195      }196   }197})198enum class SimpleEnum {199   First,200   Second201}202data class WithSimpleEnum(val enumValue: SimpleEnum = SimpleEnum.First)...

IntMatchersTest.kt

Source:IntMatchersTest.kt

1package com.sksamuel.kotest.matchers.numerics2import io.kotest.assertions.throwables.shouldThrow3import io.kotest.matchers.ints.beEven4import io.kotest.matchers.ints.beOdd5import io.kotest.matchers.ints.shouldBeBetween6import io.kotest.matchers.ints.shouldBeGreaterThan7import io.kotest.matchers.ints.shouldBeGreaterThanOrEqual8import io.kotest.matchers.ints.shouldBeLessThan9import io.kotest.matchers.ints.shouldBeLessThanOrEqual10import io.kotest.matchers.ints.shouldBeNegative11import io.kotest.matchers.ints.shouldBePositive12import io.kotest.matchers.ints.shouldBeZero13import io.kotest.matchers.ints.shouldNotBeZero14import io.kotest.core.spec.style.StringSpec15import io.kotest.matchers.should16import io.kotest.matchers.shouldBe17import io.kotest.matchers.shouldNot18import io.kotest.matchers.shouldNotBe19import io.kotest.data.forAll20import io.kotest.data.forNone21import io.kotest.data.headers22import io.kotest.data.row23import io.kotest.data.table24class IntMatchersTest : StringSpec() {25   init {26      "be positive" {27         1.shouldBePositive()28         shouldThrow<AssertionError> {29            (-1).shouldBePositive()30         }.message shouldBe "-1 should be > 0"31         shouldThrow<AssertionError> {32            (0).shouldBePositive()33         }.message shouldBe "0 should be > 0"34      }35      "be negative" {36         (-1).shouldBeNegative()37         shouldThrow<AssertionError> {38            1.shouldBeNegative()39         }.message shouldBe "1 should be < 0"40         shouldThrow<AssertionError> {41            0.shouldBeNegative()42         }.message shouldBe "0 should be < 0"43      }44      "should return expected/actual in intellij format" {45         shouldThrow<AssertionError> {46            1 shouldBe 44447         }.message shouldBe "expected:<444> but was:<1>"48      }49      "shouldBe should support ints" {50         1 shouldBe 151      }52      "isEven" {53         4 shouldBe beEven()54         3 shouldNotBe beEven()55      }56      "isOdd" {57         3 shouldBe beOdd()58         4 shouldNotBe beOdd()59      }60      "inRange" {61         3 should io.kotest.matchers.ints.beInRange(1..10)62         3 should io.kotest.matchers.ints.beInRange(3..10)63         3 should io.kotest.matchers.ints.beInRange(3..3)64         4 shouldNot io.kotest.matchers.ints.beInRange(3..3)65         4 shouldNot io.kotest.matchers.ints.beInRange(1..3)66      }67      "beGreaterThan" {68         1 should io.kotest.matchers.ints.beGreaterThan(0)69         3.shouldBeGreaterThan(2)70         shouldThrow<AssertionError> {71            2 should io.kotest.matchers.ints.beGreaterThan(3)72         }73      }74      "beLessThan" {75         1 should io.kotest.matchers.ints.beLessThan(2)76         1.shouldBeLessThan(2)77         shouldThrow<AssertionError> {78            2 shouldBe io.kotest.matchers.ints.lt(1)79         }80      }81      "beLessThanOrEqualTo" {82         1 should io.kotest.matchers.ints.beLessThanOrEqualTo(2)83         2.shouldBeLessThanOrEqual(3)84         shouldThrow<AssertionError> {85            2 shouldBe io.kotest.matchers.ints.lte(1)86         }87      }88      "beGreaterThanOrEqualTo" {89         1 should io.kotest.matchers.ints.beGreaterThanOrEqualTo(0)90         3.shouldBeGreaterThanOrEqual(1)91         shouldThrow<AssertionError> {92            2 should io.kotest.matchers.ints.beGreaterThanOrEqualTo(3)93         }94      }95      "between should test for valid interval" {96         val table = table(97            headers("a", "b"),98            row(0, 2),99            row(1, 2),100            row(0, 1),101            row(1, 1)102         )103         forAll(table) { a, b ->104            1 shouldBe io.kotest.matchers.ints.between(a, b)105            1.shouldBeBetween(a, b)106         }107      }108      "between should test for invalid interval" {109         val table = table(110            headers("a", "b"),111            row(0, 2),112            row(2, 2),113            row(4, 5),114            row(4, 6)115         )116         forNone(table) { a, b ->117            3 shouldBe io.kotest.matchers.ints.between(a, b)118         }119      }120      "shouldBeZero" {121         0.shouldBeZero()122         1.shouldNotBeZero()123         Int.MIN_VALUE.shouldNotBeZero()124         Int.MAX_VALUE.shouldNotBeZero()125      }126   }127}...

IntTest.kt

Source:IntTest.kt

1package com.sksamuel.kotest.property.arbitrary2import io.kotest.core.spec.style.FunSpec3import io.kotest.data.blocking.forAll4import io.kotest.data.row5import io.kotest.inspectors.forAll6import io.kotest.matchers.ints.*7import io.kotest.matchers.shouldBe8import io.kotest.property.Arb9import io.kotest.property.PropTest10import io.kotest.property.arbitrary.*11import io.kotest.property.checkAll12import io.kotest.property.checkCoverage13class IntTest : FunSpec({14   test("<Int, Int> should give values between min and max inclusive") {15      // Test parameters include the test for negative bounds16      forAll(17         row(-10, -1),18         row(1, 3),19         row(-100, 100),20         row(Int.MAX_VALUE - 10, Int.MAX_VALUE),21         row(Int.MIN_VALUE, Int.MIN_VALUE + 10)22      ) { vMin, vMax ->23         val expectedValues = (vMin..vMax).toSet()24         val actualValues = (1..100_000).map { Arb.int(vMin, vMax).single() }.toSet()25         actualValues shouldBe expectedValues26      }27   }28   test("Arb.int edge cases should respect min and max bounds") {29      checkCoverage("run", 25.0) {30         PropTest(iterations = 1000).checkAll<Int, Int> { min, max ->31            if (min < max) {32               classify("run")33               Arb.int(min..max).edgecases().forAll {34                  it.shouldBeBetween(min, max)35               }36            }37         }38      }39   }40   test("Arb.positiveInts should return positive ints only") {41      val numbers = Arb.positiveInt().take(1000).toSet()42      numbers.forAll { it.shouldBePositive() }43   }44   test("Arb.nonNegativeInts should return non negative ints only") {45      val numbers = Arb.nonNegativeInt().take(1000).toSet()46      numbers.forAll { it.shouldBeNonNegative() }47   }48   test("Arb.negativeInts should return negative ints only") {49      val numbers = Arb.negativeInt().take(1000).toSet()50      numbers.forAll { it.shouldBeNegative() }51   }52   test("Arb.nonPositiveInts should return non positive ints only") {53      val numbers = Arb.nonPositiveInt().take(1000).toSet()54      numbers.forAll { it.shouldBeNonPositive() }55   }56})57class UIntTest : FunSpec({58   test("<UInt, UInt> should give values between min and max inclusive") {59      forAll(60         row(1u, 3u),61         row(0u, 100u),62         row(UInt.MAX_VALUE - 10u, UInt.MAX_VALUE),63         row(UInt.MIN_VALUE, UInt.MIN_VALUE + 10u)64      ) { vMin, vMax ->65         val expectedValues = (vMin..vMax).toSet()66         val actualValues = (1..100_000).map { Arb.uInt(vMin, vMax).single() }.toSet()67         actualValues shouldBe expectedValues68      }69   }70   test("Arb.uInt edge cases should respect min and max bounds") {71      checkCoverage("run", 25.0) {72         PropTest(iterations = 1000).checkAll<UInt, UInt> { min, max ->73            if (min < max) {74               classify("run")75               Arb.uInt(min..max).edgecases().forAll {76                  it.shouldBeBetween(min, max)77               }78            }79         }80      }81   }82})...

int.kt

Source:int.kt

1package io.kotest.matchers.ints2import io.kotest.matchers.Matcher3import io.kotest.matchers.MatcherResult4import io.kotest.matchers.comparables.gt5import io.kotest.matchers.comparables.gte6import io.kotest.matchers.comparables.lt7import io.kotest.matchers.comparables.lte8import io.kotest.matchers.should9import io.kotest.matchers.shouldBe10import io.kotest.matchers.shouldNot11import io.kotest.matchers.shouldNotBe12fun Int.shouldBePositive() = this shouldBe positive()13fun positive() = object : Matcher<Int> {14  override fun test(value: Int) = MatcherResult(value > 0, "$value should be > 0", "$value should not be > 0")15}16fun Int.shouldBeNegative() = this shouldBe negative()17fun negative() = object : Matcher<Int> {18  override fun test(value: Int) = MatcherResult(value < 0, "$value should be < 0", "$value should not be < 0")19}20fun Int.shouldBeEven() = this should beEven()21fun Int.shouldNotBeEven() = this shouldNot beEven()22fun beEven() = object : Matcher<Int> {23  override fun test(value: Int): MatcherResult =24      MatcherResult(value % 2 == 0, "$value should be even", "$value should be odd")25}26fun Int.shouldBeOdd() = this should beOdd()27fun Int.shouldNotBeOdd() = this shouldNot beOdd()28fun beOdd() = object : Matcher<Int> {29  override fun test(value: Int): MatcherResult =30      MatcherResult(value % 2 == 1, "$value should be odd", "$value should be even")31}32infix fun Int.shouldBeLessThan(x: Int) = this shouldBe lt(x)33infix fun Int.shouldNotBeLessThan(x: Int) = this shouldNotBe lt(x)34infix fun Int.shouldBeLessThanOrEqual(x: Int) = this shouldBe lte(x)35infix fun Int.shouldNotBeLessThanOrEqual(x: Int) = this shouldNotBe lte(x)36infix fun Int.shouldBeGreaterThan(x: Int) = this shouldBe gt(x)37infix fun Int.shouldNotBeGreaterThan(x: Int) = this shouldNotBe gt(x)38infix fun Int.shouldBeGreaterThanOrEqual(x: Int) = this shouldBe gte(x)39infix fun Int.shouldNotBeGreaterThanOrEqual(x: Int) = this shouldNotBe gte(x)40infix fun Int.shouldBeExactly(x: Int) = this shouldBe exactly(x)41infix fun Int.shouldNotBeExactly(x: Int) = this shouldNotBe exactly(x)42fun Int.shouldBeZero() = this shouldBeExactly 043fun Int.shouldNotBeZero() = this shouldNotBeExactly 0...

Int.shouldBeNegative

Using AI Code Generation

11.shouldBeNegative()21.shouldBePositive()31.shouldBeZero()41.shouldBeBetween(0,2)51.shouldBeBetweenExclusive(0,2)61.shouldBeBetweenInclusive(0,2)71.shouldBeBetweenClosed(0,2)81.shouldBeBetweenClosedInclusive(0,2)91.shouldBeBetweenClosedExclusive(0,2)101.shouldBeBetweenClosedInclusiveExclusive(0,2)111.shouldBeBetweenClosedExclusiveInclusive(0,2)121.shouldBeBetweenInclusiveExclusive(0,2)131.shouldBeBetweenExclusiveInclusive(0,2)141.shouldBeBetweenInclusiveClosed(0,2)151.shouldBeBetweenExclusiveClosed(0,2)

Int.shouldBeNegative

Using AI Code Generation

1Int . shouldBeNegative ( - 2 )2Int . shouldBePositive ( 2 )3Int . shouldBeZero ( 0 )4Int . shouldBeOne ( 1 )5Int . shouldBeOdd ( 3 )6Int . shouldBeEven ( 2 )7Int . shouldBeInRange ( 5 , 1 .. 10 )8Int . shouldBeExactlyInRange ( 5 , 1 .. 10 )9Int . shouldBeLessThan ( 5 , 6 )10Int . shouldBeGreaterThan ( 5 , 4 )11Int . shouldBeLessOrEqualTo ( 5 , 6 )12Int . shouldBeGreaterOrEqualTo ( 5 , 4 )13Int . shouldBeBetween ( 5 , 1 , 10 )14Int . shouldBeExactlyBetween ( 5 , 1 , 10 )15Int . shouldBeCloseTo ( 5 , 4 )16Int . shouldBeCloseTo (

Int.shouldBeNegative

Using AI Code Generation

1    int shouldBeNegative = -5;2    shouldBeNegative.shouldBeNegative()3    int shouldBePositive = 5;4    shouldBePositive.shouldBePositive()5    int shouldBeZero = 0;6    shouldBeZero.shouldBeZero()7    int shouldBeBetween = 5;8    shouldBeBetween.shouldBeBetween(1, 10)9    int shouldBeBetween = 5;10    shouldBeBetween.shouldBeBetween(1, 10)11    int shouldBeBetween = 5;12    shouldBeBetween.shouldBeBetween(1, 10)13    int shouldBeBetween = 5;14    shouldBeBetween.shouldBeBetween(1, 10)15    int shouldBeBetween = 5;16    shouldBeBetween.shouldBeBetween(1, 10)17    int shouldBeBetween = 5;18    shouldBeBetween.shouldBeBetween(1, 10)19    int shouldBeBetween = 5;20    shouldBeBetween.shouldBeBetween(1, 10)21    int shouldBeBetween = 5;22    shouldBeBetween.shouldBeBetween(1, 10)23    int shouldBeBetween = 5;24    shouldBeBetween.shouldBeBetween(1, 10)25    int shouldBeBetween = 5;

Int.shouldBeNegative

Using AI Code Generation

1import io.kotest.matchers.ints.shouldBeNegative2import io.kotest.core.spec.style.StringSpec3class IntSpec : StringSpec({4"Int should be negative" {5-1.shouldBeNegative()6}7})8import io.kotest.matchers.ints.shouldBePositive9import io.kotest.core.spec.style.StringSpec10class IntSpec : StringSpec({11"Int should be positive" {121.shouldBePositive()13}14})15import io.kotest.matchers.ints.shouldBeZero16import io.kotest.core.spec.style.StringSpec17class IntSpec : StringSpec({18"Int should be zero" {190.shouldBeZero()20}21})22import io.kotest.matchers.ints.shouldBeInRange23import io.kotest.core.spec.style.StringSpec24class IntSpec : StringSpec({25"Int should be in range" {261.shouldBeInRange(1..5)27}28})29import io.kotest.matchers.ints.shouldBeExactly30import io.kotest.core.spec.style.StringSpec31class IntSpec : StringSpec({32"Int should be exactly" {331.shouldBeExactly(1)34}35})36import io.kotest.matchers.ints.shouldBeLessThan37import io.kotest.core.spec.style.StringSpec38class IntSpec : StringSpec({39"Int should be less than" {401.shouldBeLessThan(2)41}42})43import io.kotest.matchers.ints.shouldBeLessThanOrEqual44import io.kotest.core.spec.style.StringSpec45class IntSpec : StringSpec({46"Int should be less than or equal" {471.shouldBeLessThanOrEqual(1)48}49})50import io.kotest.matchers.ints.shouldBe

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.