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

Copied to Clipboard!

How to use size class of io.kotest.matchers.collections package

Best Kotest code snippet using io.kotest.matchers.collections.size

ServerTest.kt

Source:ServerTest.kt

1/*2 * Tabletop Game Library3 * Copyright (c) 2021 Carl W Spain4 *5 * Permission is hereby granted, free of charge, to any person obtaining a copy6 * of this software and associated documentation files (the "Software"), to deal7 * in the Software without restriction, including without limitation the rights8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell9 * copies of the Software, and to permit persons to whom the Software is10 * furnished to do so, subject to the following conditions:11 *12 * The above copyright notice and this permission notice shall be included in all13 * copies or substantial portions of the Software.14 *15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE21 * SOFTWARE.22 *23 */24package ttgamelib.net25import io.kotest.core.spec.style.FunSpec26import io.kotest.data.forAll27import io.kotest.data.row28import io.kotest.inspectors.forAll29import io.kotest.matchers.booleans.shouldBeFalse30import io.kotest.matchers.booleans.shouldBeTrue31import io.kotest.matchers.collections.shouldBeEmpty32import io.kotest.matchers.collections.shouldContain33import io.kotest.matchers.collections.shouldHaveSize34import io.kotest.matchers.maps.shouldContainValue35import io.kotest.matchers.shouldBe36import io.kotest.matchers.shouldNotBe37import io.kotest.matchers.types.shouldBeInstanceOf38import io.kotest.matchers.types.shouldBeTypeOf39import io.ktor.http.cio.websocket.*40import io.mockk.*41import kotlinx.serialization.json.Json42import ttgamelib.GameEngine43private inline fun<reified T: Packet> List<Frame>.decode(): List<T> {44    return map {45        Json.decodeFromString(Packet.serializer(), (it as Frame.Text).readText()) as T46    }47}48private fun createConnection(userName: String, clientId: Int): Pair<ClientConnection, MutableList<Frame>> {49    val sentPackets = mutableListOf<Frame>()50    val session = mockk<DefaultWebSocketSession>().also {51        coEvery {52            it.send(capture(sentPackets))53        } just Runs54    }55    val connection = ClientConnection(session).apply {56        name = userName57        id = clientId58    }59    return connection to sentPackets60}61internal class ServerTest : FunSpec({62    val engine = mockk<GameEngine>(relaxed = true)63    val (connection, sentPackets) = createConnection("player1", 1)64    lateinit var server: Server65    beforeEach {66        sentPackets.clear()67    }68    context("SendNamePacket") {69        val userName = "New User"70        server = Server("localhost", 1000, engine)71        test("should create new user if name is not in use") {72            server.handlePacket(SendNamePacket(userName), connection)73            val sent = sentPackets.decode<Packet>()74            sent[0].shouldBeInstanceOf<InitClientPacket>()75            (sent[0] as InitClientPacket).clientId shouldBe connection.id76            sent[1].shouldBeInstanceOf<ChatMessagePacket>()77            coVerify {78                engine.playerConnected(connection.id, userName)79            }80        }81        test("should request another name if in use") {82            val (connection2, sentPackets2) = createConnection("player2", 2)83            server.handlePacket(SendNamePacket(userName), connection2)84            val sent = sentPackets2.decode<SuggestNamePacket>()85            with (sent[0]) {86                name shouldNotBe userName87                taken.shouldContain(userName)88                disconnected.shouldBeFalse()89            }90        }91        test("should check for reconnection if disconnected") {92            server.connections.remove(connection.id)93            server.handlePacket(SendNamePacket(userName), connection)94            val sent = sentPackets.decode<SuggestNamePacket>()95            with (sent[0]) {96                name shouldNotBe userName97                taken.shouldContain(userName)98                disconnected.shouldBeTrue()99            }100        }101        test("should replace player on reconnection") {102            server.handlePacket(SendNamePacket(userName, true), connection)103            val sent = sentPackets.decode<Packet>()104            sent[0].shouldBeInstanceOf<InitClientPacket>()105            (sent[0] as InitClientPacket).clientId shouldBe connection.id106            sent[1].shouldBeInstanceOf<ChatMessagePacket>()107            coVerify {108                engine.playerReconnected(connection.id)109            }110        }111        test("should not replace player that is connected") {112            server.handlePacket(SendNamePacket(userName, true), connection)113            val sent = sentPackets.decode<SuggestNamePacket>()114            with (sent[0]) {115                name shouldNotBe userName116                disconnected.shouldBeFalse()117            }118        }119    }120    test("GameCommandPacket should be sent to game engine") {121        val packet = MessagePacket(object : GameMessage{})122        server.handlePacket(packet, connection)123        sentPackets.shouldBeEmpty()124        coVerify {125            engine.handle(connection.id, packet)126        }127    }128    context("chat command") {129        server = Server("localhost", 1000, engine)130        val connections = mutableListOf<ClientConnection>()131        val outgoing = mutableListOf<MutableList<Frame>>()132        for (i in 1..3) {133            with (createConnection("player$i", i)) {134                connections += first135                outgoing += second136                server.handlePacket(SendNamePacket(first.name), first)137            }138        }139        beforeEach {140            outgoing.forEach { it.clear() }141        }142        test("there should be three connected players") {143            connections.forAll {144                server.connections.shouldContainValue(it)145            }146        }147        test("emote should send message to all users") {148            forAll(149                row("/em is here"),150                row("/me is here")151            ) { msg ->152                server.handlePacket(ChatCommandPacket(connection.id, msg), connection)153            }154            outgoing.forEach {155                with (it.decode<ChatMessagePacket>()) {156                    shouldHaveSize(2)157                    forAll { it.message.shouldBeTypeOf<EmoteMessage>() }158                }159            }160        }161        test("whisper should send message to one user") {162            server.handlePacket(ChatCommandPacket(connections[0].id, "/w player2 a secret"), connections[0])163            outgoing[0].shouldHaveSize(1)164            outgoing[1].shouldHaveSize(1)165            outgoing[2].shouldBeEmpty()166        }167        test("whisper to unknown user should send info message to sender") {168            server.handlePacket(ChatCommandPacket(connections[1].id, "/w nobody a secret"), connections[1])169            outgoing[0].shouldHaveSize(0)170            outgoing[2].shouldHaveSize(0)171            outgoing[1].shouldHaveSize(1)172            outgoing[1].decode<ChatMessagePacket>().forAll {173                it.message.shouldBeTypeOf<InfoMessage>()174            }175        }176        test("unknown command should send info message to sender") {177            server.handlePacket(ChatCommandPacket(connections[1].id, "/foo bar baz"), connections[1])178            outgoing[0].shouldHaveSize(0)179            outgoing[2].shouldHaveSize(0)180            outgoing[1].shouldHaveSize(1)181            outgoing[1].decode<ChatMessagePacket>().forAll {182                it.message.shouldBeTypeOf<InfoMessage>()183            }184        }185    }186})...

RoomsKtTest.kt

Source:RoomsKtTest.kt

...20import org.jetbrains.exposed.sql.select21import org.jetbrains.exposed.sql.selectAll22import org.jetbrains.exposed.sql.transactions.transaction23import kotlin.random.nextInt24val directionSets = Arb.set(Arb.enum<Direction>(), 0..Direction.values().size)25val rotations = Exhaustive.ints(0..3).map { it.toShort() }26val invalidRotationValues = (Short.MIN_VALUE..Short.MAX_VALUE) - (0..3)27val invalidRotations = arbitrary(listOf(Short.MIN_VALUE, -1, 4, Short.MAX_VALUE), ShortShrinker) {28    it.random.nextInt(invalidRotationValues.indices).let { i -> invalidRotationValues[i] }.toShort()29}30class RoomsKtTest : DescribeSpec({31    useDatabase()32    describe("returnRoomToStack") {33        it("returns to empty stack") {34            transaction {35                val gameId = "ABCDEF"36                val stackId =37                    RoomStacks.insert {38                        it[this.gameId] = gameId39                        it[curIndex] = null40                        it[flipped] = false41                    } get RoomStacks.id42                val roomId =43                    Rooms.insert {44                        it[this.gameId] = gameId45                        it[roomDefId] = 1446                        it[gridX] = 047                        it[gridY] = 048                        it[rotation] = 049                    } get Rooms.id50                returnRoomToStack(gameId, roomId)51                Rooms.selectAll().shouldBeEmpty()52                val stackRows = RoomStacks.select { RoomStacks.id eq stackId }53                stackRows.count().shouldBe(1)54                stackRows.first().should {55                    it[RoomStacks.curIndex].shouldBe(0)56                }57                RoomStackContents.select { RoomStackContents.stackId eq stackId }58                    .first().should {59                        it[RoomStackContents.index].shouldBe(0)60                        it[RoomStackContents.roomDefId].shouldBe(14)61                    }62            }63        }64        it("returns to non-empty stack") {65            transaction {66                val gameId = "ABCDEF"67                val stackId = RoomStacks.insert {68                    it[this.gameId] = gameId69                    it[curIndex] = 1770                    it[flipped] = false71                } get RoomStacks.id72                RoomStackContents.insert {73                    it[this.stackId] = stackId74                    it[index] = 2575                    it[roomDefId] = 976                }77                RoomStackContents.insert {78                    it[this.stackId] = stackId79                    it[index] = 1780                    it[roomDefId] = 1381                }82                RoomStackContents.insert {83                    it[this.stackId] = stackId84                    it[index] = 385                    it[roomDefId] = 2386                }87                val roomId = Rooms.insert {88                    it[this.gameId] = gameId89                    it[roomDefId] = 1490                    it[gridX] = 091                    it[gridY] = 092                    it[rotation] = 093                } get Rooms.id94                returnRoomToStack(gameId, roomId)95                Rooms.selectAll().shouldBeEmpty()96                RoomStackContents.selectAll()97                    .map { it[RoomStackContents.index] }98                    .shouldContainExactlyInAnyOrder(0, 1, 2, 3)99            }100        }101    }102    describe("rotateDoors") {103        it("maintains number of directions") {104            forAll(directionSets, rotations) { dirs, rotation ->105                rotateDoors(dirs, rotation).size == dirs.size106            }107        }108        it("throws for invalid rotations") {109            checkAll(directionSets, invalidRotations) { dirs, rotation ->110                shouldThrow<IllegalArgumentException> { rotateDoors(dirs, rotation) }111            }112        }113        it("returns the same directions with no rotation") {114            forAll(directionSets) { dirs ->115                rotateDoors(dirs, 0) == dirs116            }117        }118        it("always returns all directions") {119            val allDirections = Direction.values().toSet()...

CategoryRepositoryCreateSpec.kt

Source:CategoryRepositoryCreateSpec.kt

...51                val savedCategory = categoryRepository.save(targetCategory)52                savedCategory.id shouldNot beNull()53                savedCategory.name shouldBe targetCategory.name54                savedCategory.children shouldNot beNull()55                savedCategory.children!! shouldHaveSize categoryChildren.size56            }57            expect("Nameê³¼ 2Depthì íì Categoriesë¡ Categoryê° ìì±ëë¤.") {58                val childrenOfChildrenOfChildren = Mock.category().chunked(10, 10).single()59                val childrenOfChildren = Mock.category(children = childrenOfChildrenOfChildren).chunked(10, 10).single()60                val categoryChildren = Mock.category(children = childrenOfChildren).chunked(20, 20).single()61                targetCategory.children = categoryChildren62                val savedCategory = categoryRepository.save(targetCategory)63                savedCategory.id shouldNot beNull()64                savedCategory.name shouldBe targetCategory.name65                savedCategory.children shouldNot beNull()66                savedCategory.children!! shouldHaveSize categoryChildren.size67                savedCategory.children!!.forEach { children ->68                    children.children shouldNot beNull()69                    children.children!! shouldHaveSize childrenOfChildren.size70                    children.children!!.forEach { childrenOfChildren ->71                        childrenOfChildren.children shouldNot beNull()72                        childrenOfChildren.children!! shouldHaveSize childrenOfChildrenOfChildren.size73                    }74                }75            }76            expect("Nameì´ ìê³ì¹ë¥¼ ì´ê³¼íë©´ Categoryë¥¼ ìì±í  ì ìë¤.") {77                val nameThreshold = 5178                targetCategory.name = Arb.string(nameThreshold, nameThreshold).next()79                val constraintViolationException = shouldThrow<ConstraintViolationException> {80                    categoryRepository.save(targetCategory)81                }82                constraintViolationException.constraintViolations shouldHave83                        singleElement {84                            isEqualCheckOneToFiftyMessage(it) && isEqualTestName(it, targetCategory)85                        }86            }...

Nel.kt

Source:Nel.kt

...59public infix fun <A> NonEmptyList<A>.shouldContainAll(ts: List<A>): Unit =60  all.shouldContainAll(ts)61public infix fun <A> NonEmptyList<A>.shouldNotContainAll(ts: List<A>): Unit =62  all.shouldNotContainAll(ts)63public infix fun <A> NonEmptyList<A>.shouldHaveSize(size: Int): NonEmptyList<A> =64  apply { all.shouldHaveSize(size) }65public infix fun <A> NonEmptyList<A>.shouldNotHaveSize(size: Int): NonEmptyList<A> =66  apply { all.shouldNotHaveSize(size) }67public infix fun <A> NonEmptyList<A>.shouldHaveSingleElement(a: A): Unit =68  all.shouldHaveSingleElement(a)69public infix fun <A> NonEmptyList<A>.shouldNotHaveSingleElement(a: A): Unit =70  all.shouldNotHaveSingleElement(a)71public fun <A : Comparable<A>> NonEmptyList<A>.shouldBeSorted(): NonEmptyList<A> =72  apply { all.shouldBeSorted() }73public fun <A : Comparable<A>> NonEmptyList<A>.shouldNotBeSorted(): NonEmptyList<A> =74  apply { all.shouldNotBeSorted() }...

Kotest.kt

Source:Kotest.kt

1package io.kotest.plugin.pitest2import io.kotest.core.spec.style.FunSpec3import io.kotest.core.spec.style.StringSpec4import io.kotest.core.spec.style.WordSpec5import io.kotest.matchers.collections.shouldBeEmpty6import io.kotest.matchers.collections.shouldHaveSize7import io.kotest.matchers.shouldBe8class Kotest : FunSpec() {9  init {10    test("StringSpecs") {11      val resultCollector = findTestsIn(StringSpecs::class.java)12      resultCollector.skipped.shouldBeEmpty()13      resultCollector.started.shouldHaveSize(2)14      resultCollector.ended.shouldHaveSize(2)15      resultCollector.failures.shouldHaveSize(1)16    }17    test("FunSpecs") {18      val resultCollector = findTestsIn(FunSpecs::class.java)19      resultCollector.skipped.shouldBeEmpty()20      resultCollector.started.shouldHaveSize(2)21      resultCollector.ended.shouldHaveSize(2)22      resultCollector.failures.shouldHaveSize(1)23    }24    test("WordSpecs") {25      val resultCollector = findTestsIn(WordSpecs::class.java)26      resultCollector.skipped.shouldBeEmpty()27      resultCollector.started.shouldHaveSize(7)28      resultCollector.ended.shouldHaveSize(7)29      resultCollector.failures.shouldHaveSize(2)30    }31  }32  private fun findTestsIn(clazz: Class<*>): TestResultCollector {33    val resultCollector = TestResultCollector()34    KotestUnitFinder().findTestUnits(clazz)35        .stream()36        .forEach { testUnit -> testUnit.execute(resultCollector) }37    return resultCollector38  }39}40private class FunSpecs : FunSpec() {41   init {42      test("passing test") { 1 shouldBe 1 }43      test("failing test") { 1 shouldBe 2 }44   }45}46private class StringSpecs : StringSpec() {47   init {48      "passing test" { 1 shouldBe 1 }49      "failing test" { 1 shouldBe 2 }50   }51}52private class WordSpecs : WordSpec() {53   init {54      "should container" should {55         "passing test" { 1 shouldBe 1 }56         "failing test" { 1 shouldBe 2 }57      }58      "when container" `when` {59         "nested should container" should {60            "passing test" { 1 shouldBe 1 }61            "failing test" { 1 shouldBe 2 }62         }63      }64   }65}...

CategoryRepositorySelectSpec.kt

Source:CategoryRepositorySelectSpec.kt

1package com.gaveship.category.domain.model2import com.gaveship.category.Mock3import io.kotest.core.spec.style.StringSpec4import io.kotest.matchers.collections.shouldHaveSize5import io.kotest.matchers.collections.singleElement6import io.kotest.matchers.nulls.beNull7import io.kotest.matchers.shouldBe8import io.kotest.matchers.shouldHave9import io.kotest.matchers.shouldNot10import io.kotest.property.arbitrary.chunked11import io.kotest.property.arbitrary.single12import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest13import org.springframework.data.jpa.repository.config.EnableJpaAuditing14@EnableJpaAuditing15@DataJpaTest(16    showSql = true,17    properties = [18        "spring.flyway.enabled=false",19        "spring.jpa.hibernate.ddl-auto=create"20    ]21)22class CategoryRepositorySelectSpec(23    private val categoryRepository: CategoryRepository24) : StringSpec() {25    init {26        "Root Categories ì¡°í ì±ê³µ Test" {27            val targetCategory = Mock.category().single()28            val savedCategory = categoryRepository.save(targetCategory)29            val savedCategoryId = savedCategory.id ?: throw IllegalArgumentException()30            val foundCategories = categoryRepository.findAll()31            foundCategories shouldHaveSize 132            foundCategories shouldHave singleElement { it.id == savedCategoryId }33        }34        "IDë¥¼ íµí Category ì¡°í ì±ê³µ Test" {35            val categoryChildren = Mock.category().chunked(10, 10).single()36            val targetCategory = Mock.category(children = categoryChildren).single()37            val savedCategory = categoryRepository.save(targetCategory)38            val savedCategoryId = savedCategory.id ?: throw IllegalArgumentException()39            val foundCategory = categoryRepository.findById(savedCategoryId).get()40            foundCategory.name shouldBe savedCategory.name41            foundCategory.children shouldNot beNull()42            foundCategory.children!!.map { it.name } shouldBe43                    targetCategory.children!!.map { it.name }44        }45    }46}...

KoTestTest.kt

Source:KoTestTest.kt

1package com.example.testingcomparison2import io.kotest.assertions.assertSoftly3import io.kotest.matchers.Matcher4import io.kotest.matchers.MatcherResult5import io.kotest.matchers.collections.shouldContain6import io.kotest.matchers.collections.shouldHaveSize7import io.kotest.matchers.collections.shouldNotContain8import io.kotest.matchers.should9import io.kotest.matchers.types.shouldBeInstanceOf10import org.junit.Test11class KoTestTest {12    private val animals = listOf("Rex", "Caramel", "Joe", "Anna")13    @Test14    fun kotest() {15        animals should containPalyndrom()16        animals17            .shouldBeInstanceOf<List<String>>()18            .shouldContain("Rex") // Doesn't let me chain here19        animals.shouldNotContain("Snow") // Doesn't let me chain here20        animals.shouldHaveSize(3)21    }22    @Test23    fun kotestSoftList() {24        assertSoftly {25            animals.shouldHaveSize(2)26            animals27                .shouldBeInstanceOf<List<String>>()28                .shouldContain("Rex") // Doesn't let me chain here29            animals.shouldNotContain("Snow") // Doesn't let me chain here30            animals.shouldHaveSize(3)31        }32    }33    fun containPalyndrom() = object : Matcher<List<String>> {34        override fun test(value: List<String>): MatcherResult {35            return MatcherResult(36                value.any { it.reversed().equals(it, ignoreCase = true) },37                "List should contain palindrome",38                "List shouldn't contain palindrome"39            )40        }41    }42}...

TodoListControllerTest.kt

Source:TodoListControllerTest.kt

1package com.example.todo.controller2import com.example.todo.model.Todo3import com.example.todo.repository.TodoRepository4import io.kotest.core.spec.style.DescribeSpec5import io.kotest.matchers.collections.shouldContainAll6import io.kotest.matchers.collections.shouldHaveSize7import io.mockk.every8import io.mockk.mockk9import io.mockk.unmockkAll10import io.mockk.verify11class TodoListControllerTest : DescribeSpec({12    lateinit var mockTodoRepository: TodoRepository13    lateinit var todoController: TodoListController14    beforeTest {15        mockTodoRepository = mockk()16        todoController = TodoListController(mockTodoRepository)17    }18    describe("Test TODO controller endpoints") {19        it("should get all the TODOs") {20            val listOfExpectedTodos = listOf(Todo(1, "Read a book", false), Todo(2, "Hit the gym", true))21            every { mockTodoRepository.getAllTodos() } returns listOfExpectedTodos22            val allTodos = todoController.getAllTodos()23            verify { mockTodoRepository.getAllTodos() }24            allTodos.shouldContainAll(listOfExpectedTodos)25            allTodos.shouldHaveSize(2)26        }27    }28    afterTest { (_, _) ->29        unmockkAll()30    }31})...

size

Using AI Code Generation

1    import io.kotest.matchers.collections.*2    import io.kotest.matchers.ints.*3    import io.kotest.matchers.longs.*4    import io.kotest.matchers.maps.*5    import io.kotest.matchers.nulls.*6    import io.kotest.matchers.sequences.*7    import io.kotest.matchers.shouldeventually.*8    import io.kotest.matchers.shouldeventually.eventually.*9    import io.kotest.matchers.shouldeventually.eventually.eventually.*10    import io.kotest.matchers.shouldeventually.eventually.eventually.eventually.*11    import io.kotest.matchers.shouldeventually.eventually.eventually.eventually.eventually.*12    import io.kotest.matchers.shouldeventually.eventually.eventually.eventually.eventually.eventually.*13    import io.kotest.matchers.shouldeventually.eventually.eventually.eventually.eventually.eventually.eventually.*

size

Using AI Code Generation

1    import io.kotest.matchers.collections.*2    import io.kotest.matchers.ints.*3    import io.kotest.matchers.longs.*4    import io.kotest.matchers.maps.*5    import io.kotest.matchers.numerics.*6    import io.kotest.matchers.nulls.*7    import io.kotest.matchers.objects.*8    import io.kotest.matchers.optionals.*9    import io.kotest.matchers.ranges.*10    import io.kotest.matchers.regex.*11    import io.kotest.matchers.sequences.*12    import io.kotest.matchers.shorts.*13    import io.kotest.matchers.strings.*14    import io.kotest.matchers.throwable.*15    import io.kotest.matchers.types.*16    import io.kotest.matchers.uri.*17    import io.kotest.matchers.uuid.*

size

Using AI Code Generation

1val list = listOf(1, 2, 3, 4)2list should haveSize(4)3list should haveSizeLessThan(5)4list should haveSizeLessThanOrEqual(4)5list should haveSizeGreaterThan(3)6list should haveSizeGreaterThanOrEqual(4)7list should haveSizeBetween(3, 5)8list should haveSizeBetweenInclusive(4, 4)9list should haveSizeBetweenExclusive(3, 4)10list should haveSizeBetweenInclusive(3, 5)11list should haveSizeBetweenExclusive(3, 5)12list should haveSizeBetweenInclusive(4, 4)13list should haveSizeBetweenExclusive(4, 4)14list should haveSizeBetweenInclusive(3, 4)15list should haveSizeBetweenExclusive(3, 4)16list should haveSizeBetweenInclusive(4, 5)17list should haveSizeBetweenExclusive(4, 5)18list should haveSizeBetweenInclusive(5, 5)19list should haveSizeBetweenExclusive(5, 5)20list should haveSizeBetweenInclusive(5, 6)21list should haveSizeBetweenExclusive(5, 6)22list should haveSizeBetweenInclusive(6, 6)23list should haveSizeBetweenExclusive(6, 6)24list should haveSizeBetweenInclusive(6, 7)25list should haveSizeBetweenExclusive(6, 7)26list should haveSizeBetweenInclusive(7, 7)27list should haveSizeBetweenExclusive(7, 7)28list should haveSizeBetweenInclusive(7, 8)29list should haveSizeBetweenExclusive(7, 8)30list should haveSizeBetweenInclusive(8, 8)31list should haveSizeBetweenExclusive(8, 8)32list should haveSizeBetweenInclusive(8, 9)33list should haveSizeBetweenExclusive(8, 9)34list should haveSizeBetweenInclusive(9, 9)35list should haveSizeBetweenExclusive(9, 9)36list should haveSizeBetweenInclusive(9, 10)37list should haveSizeBetweenExclusive(9, 10)38list should haveSizeBetweenInclusive(10, 10)39list should haveSizeBetweenExclusive(10, 10)40list should haveSizeBetweenInclusive(10, 11)41list should haveSizeBetweenExclusive(10, 11)

size

Using AI Code Generation

1class ExampleTest : FunSpec({2test("size should test size of collection") {3val list = listOf(1, 2, 3)4}5})6class ExampleTest : FunSpec({7test("size should test size of collection") {8val list = listOf(1, 2, 3)9}10})

size

Using AI Code Generation

1    val result = listOf(1,2,3).shouldHaveSize(3)2    val result = 3.shouldBe(3)3    val result = listOf(1,2,3).io.kotest.matchers.collections.size(3)4    val result = 3.io.kotest.matchers.ints.size(3)5    import io.kotest.matchers.collections.size6    import io.kotest.matchers.ints.size7    import io.kotest.matchers.size8    val result = listOf(1,2,3).size(3)9    val result = 3.size(3)10We can also import all classes from a

size

Using AI Code Generation

1    import io.kotest.matchers.collections.*2    class MySpec : StringSpec({3       "should be empty" {4          val list = emptyList<Int>()5          list.shouldBeEmpty()6       }7       "should be sorted" {8          val list = listOf(1, 2, 3)9          list.shouldBeSorted()10       }11       "should be sorted with comparator" {12          val list = listOf(3, 2, 1)13          list.shouldBeSorted { a, b -> b - a }14       }15       "should be sorted with natural ordering" {16          val list = listOf(1, 2, 3)17          list.shouldBeSorted()18       }19       "should be sorted with natural ordering and reversed" {20          val list = listOf(3, 2, 1)21          list.shouldBeSortedByDescending { it }22       }23       "should contain" {24          val list = listOf(1, 2, 3)25          list.shouldContain(1)26       }27       "should contain all" {28          val list = listOf(1, 2, 3)29          list.shouldContainAll(1, 2)30       }31       "should contain all in order" {32          val list = listOf(1, 2, 3)33          list.shouldContainAllInOrder(1, 2)34       }35       "should contain in order" {36          val list = listOf(1, 2, 3)37          list.shouldContainInOrder(1, 2)38       }39       "should contain in order only" {40          val list = listOf(1, 2, 3)41          list.shouldContainInOrderOnly(1, 2, 3)42       }43       "should contain only" {44          val list = listOf(1, 2, 3)45          list.shouldContainOnly(1, 2, 3)46       }47       "should contain only once" {48          val list = listOf(1, 2, 3, 1, 2, 3)49          list.shouldContainOnlyOnce(1, 2, 3)50       }51       "should contain only nulls" {52          val list = listOf(null, null, null)53          list.shouldContainOnlyNulls()54       }55       "should contain only nulls and elements" {

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.