How to use WordSpecShouldContainerScope.fail method of com.sksamuel.kotest.matchers.collections.SequenceMatchersTest class

Best Kotest code snippet using com.sksamuel.kotest.matchers.collections.SequenceMatchersTest.WordSpecShouldContainerScope.fail
SequenceMatchersTest.kt
Source:SequenceMatchersTest.kt
1package com.sksamuel.kotest.matchers.collections2import io.kotest.assertions.throwables.shouldThrow3import io.kotest.assertions.throwables.shouldThrowAny4import io.kotest.core.spec.style.WordSpec5import io.kotest.core.spec.style.scopes.WordSpecTerminalScope6import io.kotest.core.spec.style.scopes.WordSpecShouldContainerScope7import io.kotest.matchers.sequences.shouldBeLargerThan8import io.kotest.matchers.sequences.shouldBeSameCountAs9import io.kotest.matchers.sequences.shouldBeSmallerThan10import io.kotest.matchers.sequences.shouldBeSorted11import io.kotest.matchers.sequences.shouldBeSortedWith12import io.kotest.matchers.sequences.shouldBeUnique13import io.kotest.matchers.sequences.shouldContain14import io.kotest.matchers.sequences.shouldContainAll15import io.kotest.matchers.sequences.shouldContainAllInAnyOrder16import io.kotest.matchers.sequences.shouldContainDuplicates17import io.kotest.matchers.sequences.shouldContainExactly18import io.kotest.matchers.sequences.shouldContainInOrder19import io.kotest.matchers.sequences.shouldContainNoNulls20import io.kotest.matchers.sequences.shouldContainNull21import io.kotest.matchers.sequences.shouldContainOnlyNulls22import io.kotest.matchers.sequences.shouldExist23import io.kotest.matchers.sequences.shouldHaveAtLeastCount24import io.kotest.matchers.sequences.shouldHaveAtMostCount25import io.kotest.matchers.sequences.shouldHaveCount26import io.kotest.matchers.sequences.shouldHaveElementAt27import io.kotest.matchers.sequences.shouldHaveLowerBound28import io.kotest.matchers.sequences.shouldHaveSingleElement29import io.kotest.matchers.sequences.shouldHaveUpperBound30import io.kotest.matchers.sequences.shouldNotBeSorted31import io.kotest.matchers.sequences.shouldNotBeSortedWith32import io.kotest.matchers.sequences.shouldNotBeUnique33import io.kotest.matchers.sequences.shouldNotContain34import io.kotest.matchers.sequences.shouldNotContainAllInAnyOrder35import io.kotest.matchers.sequences.shouldNotContainExactly36import io.kotest.matchers.sequences.shouldNotContainNoNulls37import io.kotest.matchers.sequences.shouldNotContainNull38import io.kotest.matchers.sequences.shouldNotContainOnlyNulls39import io.kotest.matchers.sequences.shouldNotHaveCount40import io.kotest.matchers.sequences.shouldNotHaveElementAt41class SequenceMatchersTest : WordSpec() {42   /* PassFail */43   private suspend fun WordSpecShouldContainerScope.pass(name: String, test: suspend WordSpecTerminalScope.() -> Unit) {44      ("succeed $name")(test)45   }46   private suspend fun WordSpecShouldContainerScope.succeed(name: String, test: suspend WordSpecTerminalScope.() -> Unit) = pass(name, test)47   fun WordSpecShouldContainerScope.fail(msg: String): Nothing = io.kotest.assertions.fail(msg)48   suspend fun WordSpecShouldContainerScope.fail(name: String, test: () -> Any?) {49      ("fail $name") { shouldThrowAny(test) }50   }51   suspend inline fun <reified E : Throwable> WordSpecShouldContainerScope.abort(name: String, crossinline test: () -> Any?) {52      ("abort $name") { shouldThrow<E>(test) }53   }54   suspend inline fun <reified E : Throwable> WordSpecShouldContainerScope.`throw`(name: String, crossinline test: () -> Any?) = abort<E>(55      name,56      test)57   /* sample data */58   val empty = emptySequence<Int>()59   val single = sequenceOf(0)60   val nulls = sequenceOf<Int?>(null, null, null, null)61   val sparse = sequenceOf(null, null, null, 3)62   val countup = (0..10).asSequence()63   val countdown = (10 downTo 0).asSequence()64   val unique = sequenceOf(3, 2, 1)65   val repeating = sequenceOf(1, 2, 3, 1, 2, 3)66   val asc = { a: Int, b: Int -> a - b }67   val desc = { a: Int, b: Int -> b - a }68   /* tests */69   init {70      /* count */71      "have count" should {72         succeed("for empty when 0") {73            empty.shouldHaveCount(0)74         }75         fail("for empty when non-zero") {76            empty.shouldHaveCount(1)77         }78         succeed("for single when 1") {79            single.shouldHaveCount(1)80         }81         fail("for single when 0") {82            single.shouldHaveCount(0)83         }84         "match count() for multiple" {85            sparse.shouldHaveCount(sparse.count())86         }87         fail("to mis-match count() for multiple") {88            sparse.shouldHaveCount(sparse.count() - 1)89         }90      }91      "not have count" should {92         fail("for empty when non-zero") {93            empty.shouldNotHaveCount(0)94         }95         succeed("for empty when non-zero") {96            empty.shouldNotHaveCount(1)97         }98         fail("for single when 1") {99            single.shouldNotHaveCount(1)100         }101         succeed("for single when 0") {102            single.shouldNotHaveCount(0)103         }104         fail("to match count() for multiple") {105            sparse.shouldNotHaveCount(sparse.count())106         }107         "mis-match count() for multiple" {108            sparse.shouldNotHaveCount(sparse.count() - 1)109         }110      }111      "larger than" should {112         fail("for empty") {113            empty.shouldBeLargerThan(single)114         }115         succeed("with empty") {116            single.shouldBeLargerThan(empty)117         }118         fail("for smaller") {119            nulls.shouldBeLargerThan(countup)120         }121         fail("for same count") {122            countup.shouldBeLargerThan(countdown)123         }124         succeed("for larger") {125            countup.shouldBeLargerThan(nulls)126         }127      }128      "smaller than" should {129         succeed("for empty") {130            empty.shouldBeSmallerThan(single)131         }132         fail("with empty") {133            single.shouldBeSmallerThan(empty)134         }135         succeed("for smaller") {136            nulls.shouldBeSmallerThan(countup)137         }138         fail("for same count") {139            countup.shouldBeSmallerThan(countdown)140         }141         fail("for larger") {142            countup.shouldBeSmallerThan(nulls)143         }144      }145      "same count" should {146         fail("for empty with any") {147            empty.shouldBeSameCountAs(single)148         }149         fail("for any with empty") {150            nulls.shouldBeSameCountAs(empty)151         }152         fail("for smaller") {153            nulls.shouldBeSameCountAs(countup)154         }155         succeed("with same count") {156            countup.shouldBeSameCountAs(countdown)157         }158         fail("for larger") {159            countup.shouldBeSmallerThan(nulls)160         }161      }162      "at least count" should {163         succeed("for empty with -1") {164            empty.shouldHaveAtLeastCount(-1)165         }166         succeed("for any with -1") {167            countup.shouldHaveAtLeastCount(-1)168         }169         succeed("for empty with 0") {170            empty.shouldHaveAtLeastCount(0)171         }172         fail("for empty with 1") {173            empty.shouldHaveAtLeastCount(1)174         }175         succeed("for smaller count") {176            single.shouldHaveAtLeastCount(0)177         }178         succeed("for same count") {179            nulls.shouldHaveAtLeastCount(nulls.count())180         }181         fail("for larger count") {182            countup.shouldHaveAtLeastCount(countup.count() + 1)183         }184      }185      "at most count" should {186         fail("for empty with -1") {187            empty.shouldHaveAtMostCount(-1)188         }189         succeed("for empty with 0") {190            empty.shouldHaveAtMostCount(0)191         }192         succeed("for empty with 1") {193            empty.shouldHaveAtMostCount(1)194         }195         fail("for smaller count") {196            countup.shouldHaveAtMostCount(countup.count() - 1)197         }198         succeed("for same count") {199            countup.shouldHaveAtMostCount(countup.count())200         }201         succeed("for larger count") {202            countup.shouldHaveAtMostCount(countup.count() + 1)203         }204      }205      /* contain */206      /** null */207      "contain only nulls" should {208         succeed("for empty") {209            empty.shouldContainOnlyNulls()210         }211         fail("for single") {212            single.shouldContainOnlyNulls()213         }214         succeed("for nulls") {215            nulls.shouldContainOnlyNulls()216         }217         fail("for sparse") {218            sparse.shouldContainOnlyNulls()219         }220      }221      "not contain only nulls" should {222         fail("for empty") {223            empty.shouldNotContainOnlyNulls()224         }225         "fail for single" {226            single.shouldNotContainOnlyNulls()227         }228         fail("for nulls") {229            nulls.shouldNotContainOnlyNulls()230         }231         succeed("for sparse") {232            sparse.shouldNotContainOnlyNulls()233         }234      }235      "contain a null" should {236         fail("for empty") {237            empty.shouldContainNull()238         }239         fail("for non-nulls") {240            single.shouldContainNull()241         }242         succeed("for nulls") {243            nulls.shouldContainNull()244         }245         succeed("for sparse") {246            sparse.shouldContainNull()247         }248      }249      "not contain a null" should {250         succeed("for empty") {251            empty.shouldNotContainNull()252         }253         succeed("for non-nulls") {254            single.shouldNotContainNull()255         }256         fail("for nulls") {257            nulls.shouldNotContainNull()258         }259         fail("for sparse") {260            sparse.shouldNotContainNull()261         }262      }263      "contain no nulls" should {264         succeed("for empty") {265            empty.shouldContainNoNulls()266         }267         succeed("for non-nulls") {268            single.shouldContainNoNulls()269         }270         fail("for nulls") {271            nulls.shouldContainNoNulls()272         }273         fail("for sparse") {274            sparse.shouldContainNoNulls()275         }276      }277      "not contain no nulls" should {278         fail("for empty") {279            empty.shouldNotContainNoNulls()280         }281         fail("for non-nulls") {282            single.shouldNotContainNoNulls()283         }284         succeed("for nulls") {285            nulls.shouldNotContainNoNulls()286         }287         succeed("for sparse") {288            sparse.shouldNotContainNoNulls()289         }290      }291      /** single-value */292      "single element" should {293         fail("for empty") {294            empty.shouldHaveSingleElement(null)295         }296         succeed("for single") {297            single.shouldHaveSingleElement(single.first())298         }299         fail("for multiple") {300            nulls.shouldHaveSingleElement(null)301         }302      }303      "have element at" should {304         abort<IndexOutOfBoundsException>("for empty") {305            empty.shouldHaveElementAt(empty.count(), 0)306         }307         abort<IndexOutOfBoundsException>("when an element after the end is requested") {308            nulls.shouldHaveElementAt(nulls.count(), 0)309         }310         succeed("when the sequence has the element") {311            countup.shouldHaveElementAt(10, 10)312         }313         fail("when the sequence doesn't have the element") {314            countdown.shouldHaveElementAt(10, 10)315         }316      }317      "not have element at" should {318         abort<IndexOutOfBoundsException>("for empty") {319            empty.shouldNotHaveElementAt(empty.count(), 0)320         }321         abort<IndexOutOfBoundsException>("when an element after the end is requested") {322            nulls.shouldNotHaveElementAt(nulls.count(), 0)323         }324         fail("when the sequence has the element") {325            countup.shouldNotHaveElementAt(10, 10)326         }327         succeed("when the sequence doesn't have the element") {328            countdown.shouldNotHaveElementAt(10, 10)329         }330      }331      "contain" should {332         fail("for empty") {333            empty.shouldContain(0)334         }335         succeed("when the sequence contains the value") {336            countup.shouldContain(2)337         }338         fail("when the sequence doesn't contain the value") {339            sparse.shouldContain(2)340         }341      }342      "not contain" should {343         succeed("for empty") {344            empty.shouldNotContain(0)345         }346         fail("when the sequence contains the value") {347            countup.shouldNotContain(2)348         }349         succeed("when the sequence doesn't contain the value") {350            sparse.shouldNotContain(2)351         }352      }353      "exist" should {354         fail("for empty") {355            empty.shouldExist { true }356         }357         succeed("when always true") {358            single.shouldExist { true }359         }360         fail("when always false") {361            countup.shouldExist { false }362         }363         succeed("when matches at least one") {364            countdown.shouldExist { it % 5 == 4 }365         }366         fail("when matches none") {367            countdown.shouldExist { it > 20 }368         }369      }370      /** multiple-value */371      "contain all" should {372         succeed("for empty with empty") {373            empty.shouldContainAll(empty)374         }375         succeed("for empty with empty (variadic)") {376            empty.shouldContainAll()377         }378         fail("for empty with any other") {379            empty.shouldContainAll(single)380         }381         succeed("for any with empty") {382            single.shouldContainAll(empty)383         }384         succeed("for any with empty (variadic)") {385            single.shouldContainAll()386         }387         succeed("for subset of nulls") {388            sparse.shouldContainAll(nulls)389         }390         succeed("for subset of nulls (variadic)") {391            sparse.shouldContainAll(null, null)392         }393         succeed("for subset in order (variadic)") {394            countdown.shouldContainAll(2, 3, 5, 7)395         }396         succeed("for subset not in order (variadic)") {397            countdown.shouldContainAll(2, 5, 3, 7)398         }399         succeed("for same elements") {400            repeating.shouldContainAll(unique)401         }402         succeed("for same elements (variadic)") {403            repeating.shouldContainAll(2, 3, 1)404         }405         succeed("for same elements, repeated") {406            unique.shouldContainAll(repeating)407         }408         succeed("for same elements, repeated (variadic)") {409            unique.shouldContainAll(1, 2, 3, 1, 2, 3)410         }411      }412      "contain exactly empty" should {413         succeed("for empty") {414            empty.shouldContainExactly(sequenceOf<Int>())415         }416         succeed("for empty (variadic)") {417            empty.shouldContainExactly()418         }419         fail("for single") {420            single.shouldContainExactly(empty)421         }422         "fail for single (variadic)" {423            shouldThrowAny {424               single.shouldContainExactly()425            }426         }427         fail("for multiple") {428            nulls.shouldContainExactly(empty)429         }430         fail("for multiple (variadic)") {431            nulls.shouldContainExactly()432         }433      }434      "contain exactly non-empty" should {435         val nonempty = sparse;436         fail("for empty") {437            empty.shouldContainExactly(nonempty)438         }439         fail("for empty (variadic)") {440            empty.shouldContainExactly(*nonempty.toList().toTypedArray())441         }442         succeed("for same") {443            sparse.shouldContainExactly(nonempty)444         }445         succeed("for same (variadic)") {446            sparse.shouldContainExactly(*sparse.toList().toTypedArray())447         }448         fail("for another of different size") {449            countup.shouldContainExactly(nonempty)450         }451         fail("for another of different size (variadic)") {452            countup.shouldContainExactly(*nonempty.toList().toTypedArray())453         }454         fail("for another of same size") {455            nulls.shouldContainExactly(nonempty)456         }457         fail("for another of same size (variadic)") {458            nulls.shouldContainExactly(*nonempty.toList().toTypedArray())459         }460         fail("for same elements but different order") {461            repeating.shouldContainExactly(unique + unique)462         }463         fail("for same elements but different order (variadic)") {464            repeating.shouldContainExactly(1, 1, 2, 2, 3, 3)465         }466      }467      "not contain exactly empty" should {468         fail("for empty") {469            empty.shouldNotContainExactly(sequenceOf<Int>())470         }471         succeed("for single") {472            single.shouldNotContainExactly(empty)473         }474         succeed("for multiple") {475            nulls.shouldNotContainExactly(empty)476         }477      }478      "not contain exactly non-empty" should {479         val nonempty = sparse;480         succeed("for empty") {481            empty.shouldNotContainExactly(nonempty)482         }483         fail("for same") {484            sparse.shouldNotContainExactly(nonempty)485         }486         succeed("for another of different size") {487            countup.shouldNotContainExactly(nonempty)488         }489         succeed("for another of same size") {490            nulls.shouldNotContainExactly(nonempty)491         }492         succeed("for same elements but different order") {493            repeating.shouldNotContainExactly(unique + unique)494         }495         succeed("for same elements but different order (variadic)") {496            repeating.shouldNotContainExactly(1, 1, 2, 2, 3, 3)497         }498         succeed("for single traversable equal sequence") {499            var count1 = 0500            var count2 = 0501            val seq1 = generateSequence { if(count1 < 5) count1++ else null }502            val seq2 = generateSequence { if(count2 < 5) count2++ else null }503            seq1.shouldContainExactly(seq2)504         }505         fail("for single traversable unequal sequence") {506            var count1 = 0507            var count2 = 0508            val seq1 = generateSequence { if(count1 < 5) count1++ else null }509            val seq2 = generateSequence { if(count2 < 6) count2++ else null }510            seq1.shouldContainExactly(seq2)511         }512      }513      "contain in any order" should {514         succeed("for empty with empty") {515            empty.shouldContainAllInAnyOrder(empty)516         }517         fail("for empty with any other") {518            empty.shouldContainAllInAnyOrder(nulls)519         }520         succeed("when elements are same") {521            countdown.shouldContainAllInAnyOrder(countup)522         }523         fail("for overlapping sequence") {524            countup.shouldContainAllInAnyOrder((5..15).asSequence())525         }526         succeed("for subset, same count with nulls") {527            sparse.shouldContainAllInAnyOrder(nulls)528         }529         succeed("for subset, same count") {530            repeating.shouldContainAllInAnyOrder(unique + unique)531         }532         succeed("for subset, same count (variadic)") {533            repeating.shouldContainAllInAnyOrder(1, 1, 2, 2, 3, 3)534         }535         fail("for subset, different count with nulls") {536            sparse.shouldContainAllInAnyOrder(sparse.toSet().asSequence())537         }538         fail("for same, different count") {539            repeating.shouldContainAllInAnyOrder(unique)540         }541      }542      "not contain in any order" should {543         fail("for empty with empty") {544            empty.shouldNotContainAllInAnyOrder(empty)545         }546         succeed("for empty with any other") {547            empty.shouldNotContainAllInAnyOrder(nulls)548         }549         fail("when elements are same") {550            countdown.shouldNotContainAllInAnyOrder(countup)551         }552         succeed("for overlapping sequence") {553            countup.shouldNotContainAllInAnyOrder((5..15).asSequence())554         }555         fail("for subset, same count with nulls") {556            sparse.shouldNotContainAllInAnyOrder(nulls)557         }558         fail("for subset, same count") {559            repeating.shouldNotContainAllInAnyOrder(unique + unique)560         }561         fail("for subset, same count (variadic)") {562            repeating.shouldNotContainAllInAnyOrder(1, 1, 2, 2, 3, 3)563         }564         succeed("for subset, different count with nulls") {565            sparse.shouldNotContainAllInAnyOrder(sparse.toSet().asSequence())566         }567         succeed("for same, different count") {568            repeating.shouldNotContainAllInAnyOrder(unique)569         }570      }571      "contain in order" should {572         "with empty" {573            shouldThrowAny {574               countup.shouldContainInOrder(empty)575            }576         }577         fail("with empty (variadic)") {578            countup.shouldContainInOrder()579         }580         fail("for overlapping sequence") {581            countup.shouldContainInOrder((5..15).asSequence())582         }583         fail("for overlapping sequence (variadic)") {584            countup.shouldContainInOrder(*(5..15).toList().toTypedArray())585         }586         succeed("for subset in order") {587            countup.shouldContainInOrder(sequenceOf(2, 3, 5, 7))588         }589         succeed("for subset in order (variadic)") {590            countup.shouldContainInOrder(2, 3, 5, 7)591         }592         succeed("for subset in order with repeats") {593            repeating.shouldContainInOrder(sequenceOf(1, 3, 1, 2))594         }595         succeed("for subset in order with repeats (variadic)") {596            repeating.shouldContainInOrder(1, 3, 1, 2)597         }598         fail("for subset in order with too many repeats") {599            repeating.shouldContainInOrder(sequenceOf(1, 3, 1, 2, 2))600         }601         fail("for subset in order with too many repeats (variadic)") {602            repeating.shouldContainInOrder(1, 3, 1, 2, 2)603         }604         fail("for subset not in order") {605            countup.shouldContainInOrder(sequenceOf(2, 5, 3, 7))606         }607         fail("for subset not in order (variadic)") {608            countup.shouldContainInOrder(2, 5, 3, 7)609         }610      }611      /** unique */612      "unique" should {613         succeed("for empty") {614            empty.shouldBeUnique()615         }616         succeed("for single") {617            single.shouldBeUnique()618         }619         fail("with repeated nulls") {620            sparse.shouldBeUnique()621         }622         fail("with repeats") {623            repeating.shouldBeUnique()624         }625         succeed("for multiple unique") {626            countup.shouldBeUnique()627         }628      }629      "not unique" should {630         fail("for empty") {631            empty.shouldNotBeUnique()632         }633         fail("for single") {634            single.shouldNotBeUnique()635         }636         succeed("with repeated nulls") {637            sparse.shouldNotBeUnique()638         }639         succeed("with repeats") {640            repeating.shouldNotBeUnique()641         }642         fail("for multiple unique") {643            countup.shouldNotBeUnique()644         }645      }646      "duplicates" should {647         fail("for empty") {648            empty.shouldContainDuplicates()649         }650         fail("for single") {651            single.shouldContainDuplicates()652         }653         succeed("with repeated nulls") {654            sparse.shouldContainDuplicates()655         }656         succeed("with repeats") {657            repeating.shouldNotBeUnique()658         }659         fail("for multiple unique") {660            countup.shouldContainDuplicates()661         }662      }663      /* comparable */664      /** bound */665      "have an upper bound" should {666         succeed("for empty") {667            empty.shouldHaveUpperBound(Int.MIN_VALUE)668         }669         succeed("for single") {670            single.shouldHaveUpperBound(0)671         }672         fail("for single with wrong bound") {673            single.shouldHaveUpperBound(-1)674         }675         succeed("for multiple") {676            countup.shouldHaveUpperBound(countup.maxOrNull() ?: Int.MAX_VALUE)677         }678         fail("for multiple with wrong bound") {679            countup.shouldHaveUpperBound((countup.maxOrNull() ?: Int.MAX_VALUE) - 1)680         }681      }682      "have a lower bound" should {683         succeed("for empty") {684            empty.shouldHaveLowerBound(Int.MAX_VALUE)685         }686         succeed("for single") {687            single.shouldHaveLowerBound(0)688         }689         fail("for single with wrong bound") {690            single.shouldHaveLowerBound(1)691         }692         succeed("for multiple") {693            countup.shouldHaveLowerBound(countup.minOrNull() ?: Int.MIN_VALUE)694         }695         fail("for multiple with wrong bound") {696            countup.shouldHaveLowerBound((countup.minOrNull() ?: Int.MIN_VALUE) + 1)697         }698      }699      /** sort */700      "sorted" should {701         succeed("for empty") {702            empty.shouldBeSorted()703         }704         succeed("for single") {705            single.shouldBeSorted()706         }707         fail("for repeating") {708            repeating.shouldBeSorted()709         }710         succeed("for count-up") {711            countup.shouldBeSorted()712         }713         fail("for count-down") {714            countdown.shouldBeSorted()715         }716      }717      "not sorted" should {718         fail("for empty") {719            empty.shouldNotBeSorted()720         }721         fail("for single") {722            single.shouldNotBeSorted()723         }724         succeed("for repeating") {725            repeating.shouldNotBeSorted()726         }727         fail("for count-up") {728            countup.shouldNotBeSorted()729         }730         succeed("for count-down") {731            countdown.shouldNotBeSorted()732         }733      }734      "sorted ascending" should {735         val dir = asc736         succeed("for empty") {737            empty.shouldBeSortedWith(dir)738         }739         succeed("for single") {740            single.shouldBeSortedWith(dir)741         }742         fail("for repeating") {743            repeating.shouldBeSortedWith(dir)744         }745         succeed("for count-up") {746            countup.shouldBeSortedWith(dir)747         }748         fail("for count-down") {749            countdown.shouldBeSortedWith(dir)750         }751      }752      "sorted descending" should {753         val dir = desc754         succeed("for empty") {755            empty.shouldBeSortedWith(dir)756         }757         succeed("for single") {758            single.shouldBeSortedWith(dir)759         }760         fail("for repeating") {761            repeating.shouldBeSortedWith(dir)762         }763         fail("for count-up") {764            countup.shouldBeSortedWith(dir)765         }766         succeed("for count-down") {767            countdown.shouldBeSortedWith(dir)768         }769      }770      "not sorted ascending" should {771         val dir = asc772         fail("for empty") {773            empty.shouldNotBeSortedWith(dir)774         }775         fail("for single") {776            single.shouldNotBeSortedWith(dir)777         }778         succeed("for repeating") {779            repeating.shouldNotBeSortedWith(dir)780         }781         fail("for count-up") {782            countup.shouldNotBeSortedWith(dir)783         }784         succeed("for count-down") {785            countdown.shouldNotBeSortedWith(dir)786         }787      }788      "not sorted descending" should {789         val dir = desc790         fail("for empty") {791            empty.shouldNotBeSortedWith(dir)792         }793         fail("for single") {794            single.shouldNotBeSortedWith(dir)795         }796         succeed("for repeating") {797            repeating.shouldNotBeSortedWith(dir)798         }799         succeed("for count-up") {800            countup.shouldNotBeSortedWith(dir)801         }802         fail("for count-down") {803            countdown.shouldNotBeSortedWith(dir)804         }805      }806   }807}...
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.