Test your AI Agents with the all-new Agent to Agent Testing Platform.Learn More

How to use Array.forNone method of io.kotest.inspectors.Inspectors class

Best Kotest code snippet using io.kotest.inspectors.Inspectors.Array.forNone

CollectionInspectorsTest.kt

Source:CollectionInspectorsTest.kt

1package com.sksamuel.kotest.inspectors2import io.kotest.assertions.assertSoftly3import io.kotest.assertions.shouldFail4import io.kotest.assertions.throwables.shouldThrow5import io.kotest.assertions.throwables.shouldThrowAny6import io.kotest.core.spec.style.WordSpec7import io.kotest.inspectors.forAll8import io.kotest.inspectors.forAny9import io.kotest.inspectors.forAtLeastOne10import io.kotest.inspectors.forAtMostOne11import io.kotest.inspectors.forExactly12import io.kotest.inspectors.forNone13import io.kotest.inspectors.forOne14import io.kotest.inspectors.forSingle15import io.kotest.inspectors.forSome16import io.kotest.matchers.comparables.beGreaterThan17import io.kotest.matchers.comparables.beLessThan18import io.kotest.matchers.ints.shouldBeGreaterThan19import io.kotest.matchers.ints.shouldBeLessThan20import io.kotest.matchers.should21import io.kotest.matchers.shouldBe22@Suppress("ConstantConditionIf")23class CollectionInspectorsTest : WordSpec() {24   private val list = listOf(1, 2, 3, 4, 5)25   private val array = arrayOf(1, 2, 3, 4, 5)26   data class DummyEntry(27      val id: Int,28      val name: String,29   )30   init {31      "forAll" should {32         "pass if all elements of an array pass" {33            array.forAll {34               it.shouldBeGreaterThan(0)35            }36         }37         "pass if all elements of a collection pass" {38            list.forAll {39               it.shouldBeGreaterThan(0)40            }41         }42         "return itself" {43            array.forAll {44               it.shouldBeGreaterThan(0)45            }.forAll {46               it.shouldBeGreaterThan(0)47            }48            list.forAll {49               it.shouldBeGreaterThan(0)50            }.forAll {51               it.shouldBeGreaterThan(0)52            }53         }54         "fail when an exception is thrown inside an array" {55            shouldThrowAny {56               array.forAll {57                  if (true) throw NullPointerException()58               }59            }.message shouldBe "0 elements passed but expected 5\n" +60               "\n" +61               "The following elements passed:\n" +62               "--none--\n" +63               "\n" +64               "The following elements failed:\n" +65               "1 => java.lang.NullPointerException\n" +66               "2 => java.lang.NullPointerException\n" +67               "3 => java.lang.NullPointerException\n" +68               "4 => java.lang.NullPointerException\n" +69               "5 => java.lang.NullPointerException"70         }71         "fail when an exception is thrown inside a list" {72            shouldThrowAny {73               list.forAll {74                  if (true) throw NullPointerException()75               }76            }.message shouldBe "0 elements passed but expected 5\n" +77               "\n" +78               "The following elements passed:\n" +79               "--none--\n" +80               "\n" +81               "The following elements failed:\n" +82               "1 => java.lang.NullPointerException\n" +83               "2 => java.lang.NullPointerException\n" +84               "3 => java.lang.NullPointerException\n" +85               "4 => java.lang.NullPointerException\n" +86               "5 => java.lang.NullPointerException"87         }88      }89      "forNone" should {90         "pass if no elements pass fn test for a list" {91            list.forNone {92               it shouldBe 1093            }94         }95         "pass if no elements pass fn test for an array" {96            array.forNone {97               it shouldBe 1098            }99         }100         "pass if an element throws an exception" {101            val items = listOf(1, 2, 3)102            items.forNone {103               if (true) throw NullPointerException()104            }105         }106         "return itself" {107            list.forNone {108               it shouldBe 10109            }.forNone {110               it shouldBe 10111            }112            array.forNone {113               it shouldBe 10114            }.forNone {115               it shouldBe 10116            }117         }118         "fail if one elements passes fn test" {119            shouldThrow<AssertionError> {120               list.forNone {121                  it shouldBe 4122               }123            }.message shouldBe """1 elements passed but expected 0124The following elements passed:1254126The following elements failed:1271 => expected:<4> but was:<1>1282 => expected:<4> but was:<2>1293 => expected:<4> but was:<3>1305 => expected:<4> but was:<5>"""131         }132         "fail if all elements pass fn test" {133            shouldThrow<AssertionError> {134               list.forNone {135                  it should beGreaterThan(0)136               }137            }.message shouldBe """5 elements passed but expected 0138The following elements passed:13911402141314241435144The following elements failed:145--none--"""146         }147         "work inside assertSoftly block" {148            val dummyEntries = listOf(149               DummyEntry(id = 1, name = "first"),150               DummyEntry(id = 2, name = "second"),151            )152            assertSoftly(dummyEntries) {153               forNone {154                  it.id shouldBe 3155                  it.name shouldBe "third"156               }157            }158         }159      }160      "forSome" should {161         "pass if one elements pass test"  {162            list.forSome {163               it shouldBe 3164            }165         }166         "pass if size-1 elements pass test"  {167            list.forSome {168               it should beGreaterThan(1)169            }170         }171         "return itself" {172            list.forSome {173               it shouldBe 3174            }.forSome {175               it shouldBe 3176            }177            array.forSome {178               it shouldBe 3179            }.forSome {180               it shouldBe 3181            }182         }183         "fail if no elements pass test"  {184            shouldThrow<AssertionError> {185               array.forSome {186                  it should beLessThan(0)187               }188            }.message shouldBe """No elements passed but expected at least one189The following elements passed:190--none--191The following elements failed:1921 => 1 should be < 01932 => 2 should be < 01943 => 3 should be < 01954 => 4 should be < 01965 => 5 should be < 0"""197         }198         "fail if all elements pass test"  {199            shouldThrow<AssertionError> {200               list.forSome {201                  it should beGreaterThan(0)202               }203            }.message shouldBe """All elements passed but expected < 5204The following elements passed:20512062207320842095210The following elements failed:211--none--"""212         }213         "work inside assertSoftly block" {214            val dummyEntries = listOf(215               DummyEntry(id = 1, name = "first"),216               DummyEntry(id = 1, name = "first"),217               DummyEntry(id = 2, name = "second"),218            )219            assertSoftly(dummyEntries) {220               forSome {221                  it.id shouldBe 1222                  it.name shouldBe "first"223               }224            }225         }226      }227      "forOne" should {228         "pass if one elements pass test"  {229            list.forOne {230               it shouldBe 3231            }232         }233         "return itself" {234            list.forOne {235               it shouldBe 3236            }.forOne {237               it shouldBe 3238            }239            array.forOne {240               it shouldBe 3241            }.forOne {242               it shouldBe 3243            }244         }245         "fail if > 1 elements pass test"  {246            shouldThrow<AssertionError> {247               list.forOne {248                  it should beGreaterThan(2)249               }250            }.message shouldBe """3 elements passed but expected 1251The following elements passed:252325342545255The following elements failed:2561 => 1 should be > 22572 => 2 should be > 2"""258         }259         "fail if no elements pass test"  {260            shouldThrow<AssertionError> {261               array.forOne {262                  it shouldBe 22263               }264            }.message shouldBe """0 elements passed but expected 1265The following elements passed:266--none--267The following elements failed:2681 => expected:<22> but was:<1>2692 => expected:<22> but was:<2>2703 => expected:<22> but was:<3>2714 => expected:<22> but was:<4>2725 => expected:<22> but was:<5>"""273         }274         "work inside assertSoftly block" {275            val dummyEntries = listOf(276               DummyEntry(id = 1, name = "first"),277               DummyEntry(id = 2, name = "second"),278            )279            assertSoftly(dummyEntries) {280               forOne {281                  it.id shouldBe 1282                  it.name shouldBe "first"283               }284            }285         }286      }287      "forAny" should {288         "pass if one elements pass test"  {289            list.forAny {290               it shouldBe 3291            }292         }293         "pass if at least elements pass test"  {294            list.forAny {295               it should beGreaterThan(2)296            }297         }298         "return itself" {299            list.forAny {300               it shouldBe 3301            }.forAny {302               it shouldBe 3303            }304            array.forAny {305               it shouldBe 3306            }.forAny {307               it shouldBe 3308            }309         }310         "fail if no elements pass test"  {311            shouldThrow<AssertionError> {312               array.forAny {313                  it shouldBe 6314               }315            }.message shouldBe """0 elements passed but expected at least 1316The following elements passed:317--none--318The following elements failed:3191 => expected:<6> but was:<1>3202 => expected:<6> but was:<2>3213 => expected:<6> but was:<3>3224 => expected:<6> but was:<4>3235 => expected:<6> but was:<5>"""324         }325         "work inside assertSoftly block" {326            val dummyEntries = listOf(327               DummyEntry(id = 1, name = "first"),328               DummyEntry(id = 2, name = "second"),329            )330            assertSoftly(dummyEntries) {331               forAny {332                  it.id shouldBe 1333                  it.name shouldBe "first"334               }335            }336         }337      }338      "forExactly" should {339         "pass if exactly k elements pass"  {340            list.forExactly(2) {341               it should beLessThan(3)342            }343         }344         "fail if more elements pass test"  {345            shouldThrow<AssertionError> {346               list.forExactly(2) {347                  it should beGreaterThan(2)348               }349            }.message shouldBe """3 elements passed but expected 2350The following elements passed:351335243535354The following elements failed:3551 => 1 should be > 23562 => 2 should be > 2"""357         }358         "fail if less elements pass test"  {359            shouldThrow<AssertionError> {360               array.forExactly(2) {361                  it should beLessThan(2)362               }363            }.message shouldBe """1 elements passed but expected 2364The following elements passed:3651366The following elements failed:3672 => 2 should be < 23683 => 3 should be < 23694 => 4 should be < 23705 => 5 should be < 2"""371         }372         "fail if no elements pass test"  {373            shouldThrow<AssertionError> {374               array.forExactly(2) {375                  it shouldBe 33376               }377            }.message shouldBe """0 elements passed but expected 2378The following elements passed:379--none--380The following elements failed:3811 => expected:<33> but was:<1>3822 => expected:<33> but was:<2>3833 => expected:<33> but was:<3>3844 => expected:<33> but was:<4>3855 => expected:<33> but was:<5>"""386         }387      }388      "forAtMostOne" should {389         "pass if one elements pass test" {390            list.forAtMostOne {391               it shouldBe 3392            }393         }394         "fail if 2 elements pass test" {395            shouldThrow<AssertionError> {396               array.forAtMostOne {397                  it should beGreaterThan(3)398               }399            }.message shouldBe """2 elements passed but expected at most 1400The following elements passed:40144025403The following elements failed:4041 => 1 should be > 34052 => 2 should be > 34063 => 3 should be > 3"""407         }408         "work inside assertSoftly block" {409            val dummyEntries = listOf(410               DummyEntry(id = 1, name = "first"),411               DummyEntry(id = 2, name = "second"),412            )413            assertSoftly(dummyEntries) {414               forAtMostOne {415                  it.id shouldBe 1416                  it.name shouldBe "first"417               }418            }419         }420      }421      "forAtLeastOne" should {422         "pass if one elements pass test"  {423            list.forAtLeastOne {424               it shouldBe 3425            }426         }427         "fail if no elements pass test"  {428            shouldThrow<AssertionError> {429               array.forAtLeastOne {430                  it shouldBe 22431               }432            }.message shouldBe """0 elements passed but expected at least 1433The following elements passed:434--none--435The following elements failed:4361 => expected:<22> but was:<1>4372 => expected:<22> but was:<2>4383 => expected:<22> but was:<3>4394 => expected:<22> but was:<4>4405 => expected:<22> but was:<5>"""441         }442         "work inside assertSoftly block" {443            val dummyEntries = listOf(444               DummyEntry(id = 1, name = "first"),445               DummyEntry(id = 2, name = "second"),446            )447            assertSoftly(dummyEntries) {448               forAtLeastOne {449                  it.id shouldBe 1450                  it.name shouldBe "first"451               }452            }453         }454      }455      "forSingle" should {456         "pass list is singular, and the single element pass" {457            listOf(1).forSingle {458               it shouldBeLessThan 3459            }460         }461         "return the single element on success" {462            listOf(1).forSingle { it shouldBeLessThan 3 } shouldBe 1463         }464         "fail if collection consists of multiple elements" {465            shouldFail {466               listOf(467                  DummyEntry(id = 1, name = "first"),468                  DummyEntry(id = 2, name = "second"),469               ).forSingle {470                  it.id shouldBe 1471               }472            }.message shouldBe """473               Expected a single element in the collection, but found 2.474               The following elements passed:475               DummyEntry(id=1, name=first)476               The following elements failed:477               DummyEntry(id=2, name=second) => expected:<1> but was:<2>478            """.trimIndent()479         }480         "fail for empty collection" {481            shouldFail {482               arrayOf<Int>().forSingle {483                  it shouldBe 3484               }485            }.message shouldBe """486               Expected a single element in the collection, but it was empty.487            """.trimIndent()488         }489         "fail if single element doesn't match" {490            shouldFail {491               arrayOf(2).forSingle {492                  it shouldBe 3493               }494            }.message shouldBe """495               Expected a single element to pass, but it failed.496               The following elements passed:497               --none--498               The following elements failed:499               2 => expected:<3> but was:<2>500            """.trimIndent()501         }502         "work inside assertSoftly block" {503            val dummyEntries = listOf(504               DummyEntry(id = 1, name = "first"),505            )506            assertSoftly(dummyEntries) {507               forSingle {508                  it.id shouldBe 1509                  it.name shouldBe "first"510               }511            }512         }513      }514   }515}...

InspectorAliasTest.kt

Source:InspectorAliasTest.kt

1package com.sksamuel.kotest2import io.kotest.assertions.throwables.shouldThrowAny3import io.kotest.core.spec.style.FunSpec4import io.kotest.inspectors.shouldForAll5import io.kotest.inspectors.shouldForAny6import io.kotest.inspectors.shouldForAtLeast7import io.kotest.inspectors.shouldForAtLeastOne8import io.kotest.inspectors.shouldForAtMost9import io.kotest.inspectors.shouldForAtMostOne10import io.kotest.inspectors.shouldForExactly11import io.kotest.inspectors.shouldForNone12import io.kotest.inspectors.shouldForOne13import io.kotest.inspectors.shouldForSome14import io.kotest.matchers.comparables.shouldBeGreaterThan15import io.kotest.matchers.ints.shouldBeLessThan16import io.kotest.matchers.shouldBe17class InspectorAliasTest : FunSpec({18   val array = arrayOf(1, 2, 3)19   val list = listOf(1, 2, 3)20   val sequence = sequenceOf(1, 2, 3)21   context("forAll") {22      fun block(x: Int) = x shouldBeGreaterThan 023      test("array") {24         array.shouldForAll {25            it shouldBeLessThan 426         }27         shouldThrowAny {28            array.shouldForAll {29               it shouldBeLessThan 330            }31         }32      }33      test("list") {34         list.shouldForAll(::block)35         shouldThrowAny {36            list.shouldForAll {37               it shouldBeLessThan 338            }39         }40      }41      test("sequence") {42         sequence.shouldForAll(::block)43         shouldThrowAny {44            sequence.shouldForAll {45               it shouldBeLessThan 346            }47         }48      }49   }50   context("forOne") {51      fun block(x: Int) = x shouldBe 252      test("array") {53         array.shouldForOne(::block)54         shouldThrowAny {55            array.shouldForOne {56               it shouldBeLessThan 157            }58         }59      }60      test("list") {61         list.shouldForOne(::block)62         shouldThrowAny {63            list.shouldForOne {64               it shouldBeLessThan 165            }66         }67      }68      test("sequence") {69         sequence.shouldForOne(::block)70         shouldThrowAny {71            sequence.shouldForOne {72               it shouldBeLessThan 173            }74         }75      }76   }77   context("forExactly") {78      fun block(x: Int) = x shouldBeGreaterThan 179      val n = 280      test("array") {81         array.shouldForExactly(n, ::block)82         shouldThrowAny {83            array.shouldForExactly(n) {84               it shouldBeLessThan 185            }86         }87      }88      test("list") {89         list.shouldForExactly(n, ::block)90         shouldThrowAny {91            list.shouldForExactly(n) {92               it shouldBeLessThan 193            }94         }95      }96      test("sequence") {97         sequence.shouldForExactly(n, ::block)98         shouldThrowAny {99            sequence.shouldForExactly(n) {100               it shouldBeLessThan 1101            }102         }103      }104   }105   context("forSome") {106      fun block(x: Int) = x shouldBeGreaterThan 2107      test("array") {108         array.shouldForSome(::block)109         shouldThrowAny {110            array.shouldForSome {111               it shouldBeLessThan 1112            }113         }114      }115      test("list") {116         list.shouldForSome(::block)117         shouldThrowAny {118            list.shouldForSome {119               it shouldBeLessThan 1120            }121         }122      }123      test("sequence") {124         sequence.shouldForSome(::block)125         shouldThrowAny {126            sequence.shouldForSome {127               it shouldBeLessThan 1128            }129         }130      }131   }132   context("forAny") {133      fun block(x: Int) = x shouldBeGreaterThan 0134      test("array") {135         array.shouldForAny(::block)136         shouldThrowAny {137            array.shouldForAny {138               it shouldBeLessThan 1139            }140         }141      }142      test("list") {143         list.shouldForAny(::block)144         shouldThrowAny {145            list.shouldForAny {146               it shouldBeLessThan 1147            }148         }149      }150      test("sequence") {151         sequence.shouldForAny(::block)152         shouldThrowAny {153            sequence.shouldForAny {154               it shouldBeLessThan 1155            }156         }157      }158   }159   context("forAtLeast") {160      fun block(x: Int) = x shouldBeGreaterThan 0161      val n = 3162      test("array") {163         array.shouldForAtLeast(n, ::block)164         shouldThrowAny {165            array.shouldForAtLeast(n) {166               it shouldBeLessThan 3167            }168         }169      }170      test("list") {171         list.shouldForAtLeast(n, ::block)172         shouldThrowAny {173            list.shouldForAtLeast(n) {174               it shouldBeLessThan 3175            }176         }177      }178      test("sequence") {179         sequence.shouldForAtLeast(n, ::block)180         shouldThrowAny {181            sequence.shouldForAtLeast(n) {182               it shouldBeLessThan 3183            }184         }185      }186   }187   context("forAtLeastOne") {188      fun block(x: Int) = x shouldBeGreaterThan 0189      test("array") {190         array.shouldForAtLeastOne(::block)191         shouldThrowAny {192            array.shouldForAtLeastOne {193               it shouldBeLessThan 1194            }195         }196      }197      test("list") {198         list.shouldForAtLeastOne(::block)199         shouldThrowAny {200            list.shouldForAtLeastOne {201               it shouldBeLessThan 1202            }203         }204      }205      test("sequence") {206         sequence.shouldForAtLeastOne(::block)207         shouldThrowAny {208            sequence.shouldForAtLeastOne {209               it shouldBeLessThan 1210            }211         }212      }213   }214   context("forAtMost") {215      fun block(x: Int) = x shouldBeGreaterThan 0216      test("array") {217         val arr = arrayOf(0, 0, 1)218         arr.shouldForAtMost(1, ::block)219         shouldThrowAny {220            arr.shouldForAtMost(1) {221               it shouldBeLessThan 3222            }223         }224      }225      test("list") {226         val l = listOf(0, 1, 1)227         l.shouldForAtMost(2, ::block)228         shouldThrowAny {229            l.shouldForAtMost(2) {230               it shouldBeLessThan 3231            }232         }233      }234      test("sequence") {235         sequence.shouldForAtMost(3, ::block)236         shouldThrowAny {237            sequence.shouldForAtMost(2) {238               it shouldBeLessThan 4239            }240         }241      }242   }243   context("forNone") {244      fun block(x: Int) = x shouldBeLessThan 1245      test("array") {246         array.shouldForNone(::block)247         shouldThrowAny {248            array.shouldForNone {249               it shouldBeLessThan 4250            }251         }252      }253      test("list") {254         list.shouldForNone(::block)255         shouldThrowAny {256            list.shouldForNone {257               it shouldBeLessThan 4258            }259         }260      }261      test("sequence") {262         sequence.shouldForNone(::block)263         shouldThrowAny {264            sequence.shouldForNone {265               it shouldBeLessThan 4266            }267         }268      }269   }270   context("forAtMostOne") {271      fun block(x: Int) = x shouldBe 1272      test("array") {273         array.shouldForAtMostOne(::block)274      }275      test("list") {276         list.shouldForAtMostOne(::block)277      }278      test("sequence") {279         sequence.shouldForAtMostOne(::block)280      }281   }282})...

InspectorsTest.kt

Source:InspectorsTest.kt

1package com.sksamuel.kotest2import io.kotest.assertions.throwables.shouldThrow3import io.kotest.core.spec.style.WordSpec4import io.kotest.inspectors.forAny5import io.kotest.inspectors.forExactly6import io.kotest.inspectors.forNone7import io.kotest.inspectors.forOne8import io.kotest.inspectors.forSome9import io.kotest.matchers.comparables.beGreaterThan10import io.kotest.matchers.comparables.beLessThan11import io.kotest.matchers.should12import io.kotest.matchers.shouldBe13import io.kotest.matchers.shouldNotBe14class InspectorsTest : WordSpec() {15   private val list = listOf(1, 2, 3, 4, 5)16   private val array = arrayOf(1, 2, 3, 4, 5)17   private val charSequence = "charSequence"18   init {19      "forNone" should {20         "pass if no elements pass fn test for a list" {21            list.forNone {22               it shouldBe 1023            }24         }25         "pass if no elements pass fn test for a char sequence" {26            charSequence.forNone {27               it shouldBe 'x'28            }29         }30         "pass if no elements pass fn test for an array" {31            array.forNone {32               it shouldBe 1033            }34         }35         "fail if one elements passes fn test" {36            shouldThrow<AssertionError> {37               list.forNone {38                  it shouldBe 439               }40            }.message shouldBe """1 elements passed but expected 041The following elements passed:42443The following elements failed:441 => expected:<4> but was:<1>452 => expected:<4> but was:<2>463 => expected:<4> but was:<3>475 => expected:<4> but was:<5>"""48         }49         "fail if all elements pass fn test" {50            shouldThrow<AssertionError> {51               list.forNone {52                  it should beGreaterThan(0)53               }54            }.message shouldBe """5 elements passed but expected 055The following elements passed:56157258359460561The following elements failed:62--none--"""63         }64      }65      "forSome" should {66         "pass if one elements pass test"  {67            list.forSome {68               it shouldBe 369            }70         }71         "pass if size-1 elements pass test"  {72            list.forSome {73               it should beGreaterThan(1)74            }75         }76         "pass if two elements pass test for a char sequence" {77            charSequence.forSome {78               it shouldBe 'c'79            }80         }81         "fail if no elements pass test"  {82            shouldThrow<AssertionError> {83               array.forSome {84                  it should beLessThan(0)85               }86            }.message shouldBe """No elements passed but expected at least one87The following elements passed:88--none--89The following elements failed:901 => 1 should be < 0912 => 2 should be < 0923 => 3 should be < 0934 => 4 should be < 0945 => 5 should be < 0"""95         }96         "fail if all elements pass test"  {97            shouldThrow<AssertionError> {98               list.forSome {99                  it should beGreaterThan(0)100               }101            }.message shouldBe """All elements passed but expected < 5102The following elements passed:10311042105310641075108The following elements failed:109--none--"""110         }111      }112      "forOne" should {113         "pass if one elements pass test"  {114            list.forOne {115               it shouldBe 3116            }117         }118         "fail if all elements pass test for a char sequence" {119            shouldThrow<AssertionError> {120               charSequence.forOne { t ->121                  t shouldNotBe 'X'122               }123            }.message shouldBe """12 elements passed but expected 1124The following elements passed:125c126h127a128r129S130e131q132u133e134n135... and 2 more passed elements136The following elements failed:137--none--"""138         }139         "fail if > 1 elements pass test"  {140            shouldThrow<AssertionError> {141               list.forOne { t ->142                  t should beGreaterThan(2)143               }144            }.message shouldBe """3 elements passed but expected 1145The following elements passed:146314741485149The following elements failed:1501 => 1 should be > 21512 => 2 should be > 2"""152         }153         "fail if no elements pass test"  {154            shouldThrow<AssertionError> {155               array.forOne { t ->156                  t shouldBe 22157               }158            }.message shouldBe """0 elements passed but expected 1159The following elements passed:160--none--161The following elements failed:1621 => expected:<22> but was:<1>1632 => expected:<22> but was:<2>1643 => expected:<22> but was:<3>1654 => expected:<22> but was:<4>1665 => expected:<22> but was:<5>"""167         }168      }169      "forAny" should {170         "pass if one elements pass test"  {171            list.forAny { t ->172               t shouldBe 3173            }174         }175         "pass if at least elements pass test"  {176            list.forAny { t ->177               t should beGreaterThan(2)178            }179         }180         "pass if all elements pass test for a char sequence" {181            charSequence.forAny {182               it shouldNotBe 'X'183            }184         }185         "fail if no elements pass test"  {186            shouldThrow<AssertionError> {187               array.forAny { t ->188                  t shouldBe 6189               }190            }.message shouldBe """0 elements passed but expected at least 1191The following elements passed:192--none--193The following elements failed:1941 => expected:<6> but was:<1>1952 => expected:<6> but was:<2>1963 => expected:<6> but was:<3>1974 => expected:<6> but was:<4>1985 => expected:<6> but was:<5>"""199         }200      }201      "forExactly" should {202         "pass if exactly k elements pass"  {203            list.forExactly(2) { t ->204               t should beLessThan(3)205            }206         }207         "pass if exactly k elements pass for a char sequence" {208            charSequence.forExactly(1) {209               it shouldBe 'h'210            }211         }212         "fail if more elements pass test"  {213            shouldThrow<AssertionError> {214               list.forExactly(2) { t ->215                  t should beGreaterThan(2)216               }217            }.message shouldBe """3 elements passed but expected 2218The following elements passed:219322042215222The following elements failed:2231 => 1 should be > 22242 => 2 should be > 2"""225         }226         "fail if less elements pass test"  {227            shouldThrow<AssertionError> {228               array.forExactly(2) { t ->229                  t should beLessThan(2)230               }231            }.message shouldBe """1 elements passed but expected 2232The following elements passed:2331234The following elements failed:2352 => 2 should be < 22363 => 3 should be < 22374 => 4 should be < 22385 => 5 should be < 2"""239         }240         "fail if no elements pass test"  {241            shouldThrow<AssertionError> {242               list.forExactly(2) { t ->243                  t shouldBe 33244               }245            }.message shouldBe """0 elements passed but expected 2246The following elements passed:247--none--248The following elements failed:2491 => expected:<33> but was:<1>2502 => expected:<33> but was:<2>2513 => expected:<33> but was:<3>2524 => expected:<33> but was:<4>2535 => expected:<33> but was:<5>"""254         }255      }256   }257}...

Inspectors.kt

Source:Inspectors.kt

1package com.github.shwaka.kotest.inspectors2import io.kotest.inspectors.ElementPass3import io.kotest.inspectors.runTests4fun <T> Sequence<T>.forAll(fn: (T) -> Unit) = toList().forAll(fn)5fun <T> Array<T>.forAll(fn: (T) -> Unit) = asList().forAll(fn)6fun <T> Collection<T>.forAll(fn: (T) -> Unit) {7    val results = runTests(this, fn)8    val passed = results.filterIsInstance<ElementPass<T>>()9    if (passed.size < this.size) {10        val msg = "${passed.size} elements passed but expected ${this.size}"11        buildAssertionError(msg, results)12    }13}14fun <T> Sequence<T>.forOne(fn: (T) -> Unit) = toList().forOne(fn)15fun <T> Array<T>.forOne(fn: (T) -> Unit) = asList().forOne(fn)16fun <T> Collection<T>.forOne(fn: (T) -> Unit) = forExactly(1, fn)17fun <T> Sequence<T>.forExactly(k: Int, fn: (T) -> Unit) = toList().forExactly(k, fn)18fun <T> Array<T>.forExactly(k: Int, fn: (T) -> Unit) = toList().forExactly(k, fn)19fun <T> Collection<T>.forExactly(k: Int, fn: (T) -> Unit) {20    val results = runTests(this, fn)21    val passed = results.filterIsInstance<ElementPass<T>>()22    if (passed.size != k) {23        val msg = "${passed.size} elements passed but expected $k"24        buildAssertionError(msg, results)25    }26}27fun <T> Sequence<T>.forSome(fn: (T) -> Unit) = toList().forSome(fn)28fun <T> Array<T>.forSome(fn: (T) -> Unit) = toList().forSome(fn)29fun <T> Collection<T>.forSome(fn: (T) -> Unit) {30    val results = runTests(this, fn)31    val passed = results.filterIsInstance<ElementPass<T>>()32    if (passed.isEmpty()) {33        buildAssertionError("No elements passed but expected at least one", results)34    } else if (passed.size == size) {35        buildAssertionError("All elements passed but expected < $size", results)36    }37}38fun <T> Sequence<T>.forAny(fn: (T) -> Unit) = toList().forAny(fn)39fun <T> Array<T>.forAny(fn: (T) -> Unit) = toList().forAny(fn)40fun <T> Collection<T>.forAny(fn: (T) -> Unit) = forAtLeastOne(fn)41fun <T> Sequence<T>.forAtLeastOne(fn: (T) -> Unit) = toList().forAtLeastOne(fn)42fun <T> Array<T>.forAtLeastOne(fn: (T) -> Unit) = toList().forAtLeastOne(fn)43fun <T> Collection<T>.forAtLeastOne(f: (T) -> Unit) = forAtLeast(1, f)44fun <T> Sequence<T>.forAtLeast(k: Int, fn: (T) -> Unit) = toList().forAtLeast(k, fn)45fun <T> Array<T>.forAtLeast(k: Int, fn: (T) -> Unit) = toList().forAtLeast(k, fn)46fun <T> Collection<T>.forAtLeast(k: Int, fn: (T) -> Unit) {47    val results = runTests(this, fn)48    val passed = results.filterIsInstance<ElementPass<T>>()49    if (passed.size < k) {50        val msg = "${passed.size} elements passed but expected at least $k"51        buildAssertionError(msg, results)52    }53}54fun <T> Sequence<T>.forAtMostOne(fn: (T) -> Unit) = toList().forAtMostOne(fn)55fun <T> Array<T>.forAtMostOne(fn: (T) -> Unit) = toList().forAtMostOne(fn)56fun <T> Collection<T>.forAtMostOne(fn: (T) -> Unit) = forAtMost(1, fn)57fun <T> Sequence<T>.forAtMost(k: Int, fn: (T) -> Unit) = toList().forAtMost(k, fn)58fun <T> Array<T>.forAtMost(k: Int, fn: (T) -> Unit) = toList().forAtMost(k, fn)59fun <T> Collection<T>.forAtMost(k: Int, fn: (T) -> Unit) {60    val results = runTests(this, fn)61    val passed = results.filterIsInstance<ElementPass<T>>()62    if (passed.size > k) {63        val msg = "${passed.size} elements passed but expected at most $k"64        buildAssertionError(msg, results)65    }66}67fun <T> Sequence<T>.forNone(fn: (T) -> Unit) = toList().forNone(fn)68fun <T> Array<T>.forNone(fn: (T) -> Unit) = toList().forNone(fn)69fun <T> Collection<T>.forNone(f: (T) -> Unit) {70    val results = runTests(this, f)71    val passed = results.filterIsInstance<ElementPass<T>>()72    if (passed.isNotEmpty()) {73        val msg = "${passed.size} elements passed but expected ${0}"74        buildAssertionError(msg, results)75    }76}...

InspectorAliases.kt

Source:InspectorAliases.kt

1package io.kotest.inspectors2/** Alias for [Sequence.forAll] */3fun <T> Sequence<T>.shouldForAll(fn: (T) -> Unit) = forAll(fn)4/** Alias for [Array.forAll] */5fun <T> Array<T>.shouldForAll(fn: (T) -> Unit) = forAll(fn)6/** Alias for [Collection.forAll] */7fun <T> Collection<T>.shouldForAll(fn: (T) -> Unit) = forAll(fn)8/** Alias for [Sequence.forOne] */9fun <T> Sequence<T>.shouldForOne(fn: (T) -> Unit) = forOne(fn)10/** Alias for [Array.forOne] */11fun <T> Array<T>.shouldForOne(fn: (T) -> Unit) = forOne(fn)12/** Alias for [Collection.forOne] */13fun <T> Collection<T>.shouldForOne(fn: (T) -> Unit) = forOne(fn)14/** Alias for [Sequence.forExactly] */15fun <T> Sequence<T>.shouldForExactly(k: Int, fn: (T) -> Unit) = forExactly(k, fn)16/** Alias for [Array.forExactly] */17fun <T> Array<T>.shouldForExactly(k: Int, fn: (T) -> Unit) = forExactly(k, fn)18/** Alias for [Collection.forExactly] */19fun <T> Collection<T>.shouldForExactly(k: Int, fn: (T) -> Unit) = forExactly(k, fn)20/** Alias for [Sequence.forSome] */21fun <T> Sequence<T>.shouldForSome(fn: (T) -> Unit) = forSome(fn)22/** Alias for [Array.forSome] */23fun <T> Array<T>.shouldForSome(fn: (T) -> Unit) = forSome(fn)24/** Alias for [Collection.forSome] */25fun <T> Collection<T>.shouldForSome(fn: (T) -> Unit) = forSome(fn)26/** Alias for [Sequence.forAny] */27fun <T> Sequence<T>.shouldForAny(fn: (T) -> Unit) = forAny(fn)28/** Alias for [Array.forAny] */29fun <T> Array<T>.shouldForAny(fn: (T) -> Unit) = forAny(fn)30/** Alias for [Collection.forAny] */31fun <T> Collection<T>.shouldForAny(fn: (T) -> Unit) = forAny(fn)32/** Alias for [Sequence.forAtLeastOne] */33fun <T> Sequence<T>.shouldForAtLeastOne(fn: (T) -> Unit) = forAtLeastOne(fn)34/** Alias for [Array.forAtLeastOne] */35fun <T> Array<T>.shouldForAtLeastOne(fn: (T) -> Unit) = forAtLeastOne(fn)36/** Alias for [Collection.forAtLeastOne] */37fun <T> Collection<T>.shouldForAtLeastOne(fn: (T) -> Unit) = forAtLeastOne(fn)38/** Alias for [Sequence.forAtLeast] */39fun <T> Sequence<T>.shouldForAtLeast(k: Int, fn: (T) -> Unit) = forAtLeast(k, fn)40/** Alias for [Array.forAtLeast] */41fun <T> Array<T>.shouldForAtLeast(k: Int, fn: (T) -> Unit) = forAtLeast(k, fn)42/** Alias for [Collection.forAtLeast] */43fun <T> Collection<T>.shouldForAtLeast(k: Int, fn: (T) -> Unit) = forAtLeast(k, fn)44/** Alias for [Sequence.forAtMostOne] */45fun <T> Sequence<T>.shouldForAtMostOne(fn: (T) -> Unit) = forAtMostOne(fn)46/** Alias for [Array.forAtMostOne] */47fun <T> Array<T>.shouldForAtMostOne(fn: (T) -> Unit) = forAtMostOne(fn)48/** Alias for [Collection.forAtMostOne] */49fun <T> Collection<T>.shouldForAtMostOne(fn: (T) -> Unit) = forAtMostOne(fn)50/** Alias for [Sequence.forAtMost] */51fun <T> Sequence<T>.shouldForAtMost(k: Int, fn: (T) -> Unit) = forAtMost(k, fn)52/** Alias for [Array.forAtMost] */53fun <T> Array<T>.shouldForAtMost(k: Int, fn: (T) -> Unit) = forAtMost(k, fn)54/** Alias for [Collection.forAtMost] */55fun <T> Collection<T>.shouldForAtMost(k: Int, fn: (T) -> Unit) = forAtMost(k, fn)56/** Alias for [Sequence.forNone] */57fun <T> Sequence<T>.shouldForNone(fn: (T) -> Unit) = forNone(fn)58/** Alias for [Array.forNone] */59fun <T> Array<T>.shouldForNone(fn: (T) -> Unit) = forNone(fn)60/** Alias for [Collection.forNone] */61fun <T> Collection<T>.shouldForNone(fn: (T) -> Unit) = forNone(fn)...

AvroBinaryOutputStreamTest.kt

Source:AvroBinaryOutputStreamTest.kt

1package com.github.avrokotlin.avro4k.io2import com.github.avrokotlin.avro4k.Avro3import io.kotest.core.spec.style.StringSpec4import io.kotest.inspectors.forNone5import io.kotest.matchers.string.shouldContain6import kotlinx.serialization.Serializable7import java.io.ByteArrayOutputStream8class AvroBinaryOutputStreamTest : StringSpec({9   val ennio = Composer("ennio morricone", "rome", listOf(Work("legend of 1900", 1986), Work("ecstasy of gold", 1969)))10   val hans = Composer("hans zimmer", "frankfurt", listOf(Work("batman begins", 2007), Work("dunkirk", 2017)))11   "AvroBinaryOutputStream should not write schemas"  {12      val baos = ByteArrayOutputStream()13      Avro.default.openOutputStream(Composer.serializer()) {14         encodeFormat = AvroEncodeFormat.Binary15      }.to(baos).write(ennio).write(hans).close()16      // the schema should not be written in a binary stream17      listOf("name", "birthplace", "works", "year").forNone {18         String(baos.toByteArray()).shouldContain(it)19      }20   }21}) {22   @Serializable23   data class Work(val name: String, val year: Int)24   @Serializable25   data class Composer(val name: String, val birthplace: String, val works: List<Work>)26}...

NumbersTestWithInspectors.kt

Source:NumbersTestWithInspectors.kt

1import io.kotest.core.spec.style.StringSpec2import io.kotest.inspectors.*3import io.kotest.matchers.ints.shouldBeGreaterThanOrEqual4import io.kotest.matchers.shouldBe56class NumbersTestWithInspectors : StringSpec({7  val numbers = Array(10) { it + 1 }89  "all are non-negative" {10    numbers.forAll { it shouldBeGreaterThanOrEqual 0 }11  }1213  "none is zero" { numbers.forNone { it shouldBe 0 } }1415  "a single 10" { numbers.forOne { it shouldBe 10 } }1617  "at most one 0" { numbers.forAtMostOne { it shouldBe 0 } }1819  "at least one odd number" {20    numbers.forAtLeastOne { it % 2 shouldBe 1 }21  }2223  "at most five odd numbers" {24    numbers.forAtMost(5) { it % 2 shouldBe 1 }25  }2627  "at least three even numbers" {28    numbers.forAtLeast(3) { it % 2 shouldBe 0 }29  }3031  "some numbers are odd" { numbers.forAny { it % 2 shouldBe 1 } }3233  "some but not all numbers are even" {34    numbers.forSome { it % 2 shouldBe 0 }35  }3637  "exactly five numbers are even" {38    numbers.forExactly(5) { it % 2 shouldBe 0 }39  }
...

Array.forNone

Using AI Code Generation

1val array = arrayOf(1, 2, 3, 4, 5)2array.forNone { it > 5 } shouldBe true3array.forNone { it < 1 } shouldBe false4val array = arrayOf(1, 2, 3, 4, 5)5array.forExactly(2) { it % 2 shouldBe 0 }6array.forExactly(3) { it % 2 shouldBe 1 }7val array = arrayOf(1, 2, 3, 4, 5)8array.forAtLeast(2) { it % 2 shouldBe 0 }9array.forAtLeast(3) { it % 2 shouldBe 1 }10val array = arrayOf(1, 2, 3, 4, 5)11array.forAtMost(2) { it % 2 shouldBe 1 }12array.forAtMost(3) { it % 2 shouldBe 0 }13val array = arrayOf(1, 2, 3, 4, 5)14array.forAny { it % 2 shouldBe 0 }15array.forAny { it % 2 shouldBe 1 }16val array = arrayOf(1, 2, 3, 4, 5)17array.forNone { it > 5 } shouldBe true18array.forNone { it < 1 } shouldBe false19val array = arrayOf(1, 2, 3, 4, 5)20array.forExactly(2) { it % 2 shouldBe 0 }21array.forExactly(3) { it % 2 shouldBe 1 }22val array = arrayOf(1, 2, 3, 4, 5)23array.forAtLeast(2)

Array.forNone

Using AI Code Generation

1fun `test array for none` () {2val array = arrayOf ( 1 , 2 , 3 , 4 , 5 )3array . forNone { it > 10 } shouldNotThrowAnyException4array . forNone { it > 5 } shouldThrow AssertionError :: class5}6fun `test array for one` () {7val array = arrayOf ( 1 , 2 , 3 , 4 , 5 )8array . forOne { it > 10 } shouldThrow AssertionError :: class9array . forOne { it > 5 } shouldNotThrowAnyException10}11fun `test array for all` () {12val array = arrayOf ( 1 , 2 , 3 , 4 , 5 )13array . forAll { it > 0 } shouldNotThrowAnyException14array . forAll { it > 5 } shouldThrow AssertionError :: class15}16fun `test array for exactly` () {17val array = arrayOf ( 1 , 2 , 3 , 4 , 5 )18array . forExactly ( 3 ) { it > 0 } shouldNotThrowAnyException19array . forExactly ( 5 ) { it > 0 } shouldNotThrowAnyException20array . forExactly ( 3 ) { it > 5 } shouldThrow AssertionError :: class21array . forExactly ( 5 ) { it > 5 } shouldThrow AssertionError :: class22}23fun `test array for at least` () {24val array = arrayOf ( 1 , 2 , 3 , 4 , 5 )25array . forAtLeast ( 3 ) { it > 0 } shouldNotThrowAnyException26array . forAtLeast ( 5 ) { it > 0 } shouldNotThrowAnyException27array . forAtLeast ( 3 ) { it > 5 } shouldThrow AssertionError :: class28array . forAtLeast ( 5 ) { it > 5 } shouldThrow AssertionError

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.