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

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

LogSpyExtensionsTest.kt

Source:LogSpyExtensionsTest.kt

...3import io.kotest.core.spec.style.FreeSpec4import io.kotest.inspectors.forAll5import io.kotest.matchers.Matcher6import io.kotest.matchers.MatcherResult7import io.kotest.matchers.collections.containExactly8import io.kotest.matchers.should9internal class LogSpyExtensionsTest : FreeSpec() {10    init {11        "spy by type" - {12            "creates spy for type" - {13                useFakeSpyProvider { provider ->14                    val spy = spyOn<TestObject> { provider.addEvent(TestObject::class, event()) }15                    spy.events() should containExactly(event())16                }17            }18            "closes underlying spy after block" - {19                useFakeSpyProvider { provider ->20                    spyOn<TestObject> {}21                    provider.allInstancesFor(TestObject::class).forAll { it.shouldBeClosed() }22                }23            }24            "closes underlying spy after faulty block" - {25                useFakeSpyProvider { provider ->26                    shouldThrow<java.lang.RuntimeException> {27                        spyOn<TestObject> { throw RuntimeException("Test exception") }28                    }29                    provider.allInstancesFor(TestObject::class).forAll { it.shouldBeClosed() }30                }31            }32            "takes snapshot of recorded events" - {33                useFakeSpyProvider { provider ->34                    val spy = spyOn<TestObject> { provider.addEvent(TestObject::class, event1()) }35                    provider.addEvent(TestObject::class, event2())36                    spy.events() should containExactly(event1())37                }38            }39            "creates new spy for each request" - {40                useFakeSpyProvider { provider ->41                    spyOn<TestObject> {42                        provider.addEvent(TestObject::class, event1())43                        val spy =44                            spyOn<TestObject> { provider.addEvent(TestObject::class, event2()) }45                        spy.events() should containExactly(event2())46                    }47                }48            }49            "delayed spying" - {50                "creates spy for block" - {51                    useFakeSpyProvider { provider ->52                        val spy = spyForLogger<TestObject>()53                        provider.addEvent(TestObject::class, event1())54                        val sectionSpy = spy { provider.addEvent(TestObject::class, event2()) }55                        sectionSpy.events() should containExactly(event2())56                    }57                }58            }59        }60        "spy by literal" - {61            "creates spy for literal" - {62                useFakeSpyProvider { provider ->63                    val spy = spyOn("a") { provider.addEvent("a", event()) }64                    spy.events() should containExactly(event())65                }66            }67            "closes underlying spy" - {68                useFakeSpyProvider { provider ->69                    spyOn("a") {}70                    provider.allInstancesFor("a").forAll { it.shouldBeClosed() }71                }72            }73            "closes underlying spy after faulty block" - {74                useFakeSpyProvider { provider ->75                    shouldThrow<java.lang.RuntimeException> {76                        spyOn("a") { throw RuntimeException("Test exception") }77                    }78                    provider.allInstancesFor("a").forAll { it.shouldBeClosed() }79                }80            }81            "takes snapshot of recorded events" - {82                useFakeSpyProvider { provider ->83                    val spy = spyOn("a") { provider.addEvent("a", event1()) }84                    provider.addEvent("a", event2())85                    spy.events() should containExactly(event1())86                }87            }88            "creates new spy for each request" - {89                useFakeSpyProvider { provider ->90                    spyOn("a") {91                        provider.addEvent("a", event1())92                        val spy = spyOn("a") { provider.addEvent("a", event2()) }93                        spy.events() should containExactly(event2())94                    }95                }96            }97            "delayed spying" - {98                "creates spy for block" - {99                    useFakeSpyProvider { provider ->100                        val spy = spyForLogger("a")101                        provider.addEvent("a", event1())102                        val sectionSpy = spy { provider.addEvent("a", event2()) }103                        sectionSpy.events() should containExactly(event2())104                    }105                }106            }107        }108    }109}110private fun useFakeSpyProvider(block: (FakeSpyProvider) -> Unit) {111    val provider = FakeSpyProvider()112    ServiceLoaderWrapper.predefine<SpyProvider>(provider)113    block(provider)114}115private fun event() = SpiedEvent("Test", SpiedEvent.Level.DEBUG, null, emptyMap())116private fun event1() = SpiedEvent("Test 1", SpiedEvent.Level.DEBUG, null, emptyMap())117private fun event2() = SpiedEvent("Test 2", SpiedEvent.Level.DEBUG, null, emptyMap())...

SyncFeatureSpec.kt

Source:SyncFeatureSpec.kt

1package io.github.mishkun.puerh.core2import io.kotest.core.spec.style.FreeSpec3import io.kotest.matchers.collections.beEmpty4import io.kotest.matchers.collections.containExactly5import io.kotest.matchers.should6import io.kotest.matchers.shouldBe7class SyncFeatureSpec : FreeSpec({8    "describe current state" - {9        "it should be initialized with state"  {10            val testFeature = createTestFeature()11            testFeature.currentState shouldBe SyncTestFeature.State(0)12        }13        "it should update state on message" {14            val testFeature = createTestFeature()15            testFeature.accept(SyncTestFeature.Msg)16            testFeature.currentState shouldBe SyncTestFeature.State(1)17        }18    }19    "describe state subscription" - {20        "it should get first state on subscription" {21            val testFeature = createTestFeature()22            var gotState: SyncTestFeature.State? = null23            val subscriber: (SyncTestFeature.State) -> Unit = { gotState = it }24            testFeature.listenState(subscriber)25            gotState shouldBe SyncTestFeature.State(0)26        }27        "it should always get exactly one latest state on subscription" {28            val testFeature = createTestFeature()29            val states = mutableListOf<SyncTestFeature.State>()30            val subscriber: (SyncTestFeature.State) -> Unit = { states.add(it) }31            testFeature.accept(SyncTestFeature.Msg)32            testFeature.listenState(subscriber)33            states should containExactly(SyncTestFeature.State(1))34        }35        "it should subscribe to state updates" {36            val testFeature = createTestFeature()37            val states = mutableListOf<SyncTestFeature.State>()38            val subscriber: (SyncTestFeature.State) -> Unit = { states.add(it) }39            testFeature.listenState(subscriber)40            testFeature.accept(SyncTestFeature.Msg)41            states should containExactly(SyncTestFeature.State(0), SyncTestFeature.State(1))42        }43    }44    "describe effects subscription" - {45        "it should subscribe to effects" {46            val testFeature = createTestFeature()47            val effects = mutableListOf<SyncTestFeature.Eff>()48            val subscriber: (SyncTestFeature.Eff) -> Unit = { effects.add(it) }49            testFeature.listenEffect(subscriber)50            testFeature.accept(SyncTestFeature.Msg)51            effects should containExactly(SyncTestFeature.Eff)52        }53        "it should not get any effects on subscription" {54            val testFeature = createTestFeature()55            val effects = mutableListOf<SyncTestFeature.Eff>()56            val subscriber: (SyncTestFeature.Eff) -> Unit = { effects.add(it) }57            testFeature.accept(SyncTestFeature.Msg)58            testFeature.listenEffect(subscriber)59            effects should beEmpty()60        }61    }62    "describe feature disposal" - {63        "it should not get any effects after calling cancel method" {64            val testFeature = createTestFeature()65            val effects = mutableListOf<SyncTestFeature.Eff>()66            val subscriber: (SyncTestFeature.Eff) -> Unit = { effects.add(it) }67            testFeature.listenEffect(subscriber)68            testFeature.cancel()69            testFeature.accept(SyncTestFeature.Msg)70            effects should beEmpty()71        }72        "it should not get any new states after calling cancel method" {73            val testFeature = createTestFeature()74            val states = mutableListOf<SyncTestFeature.State>()75            val subscriber: (SyncTestFeature.State) -> Unit = { states.add(it) }76            testFeature.listenState(subscriber)77            testFeature.cancel()78            testFeature.accept(SyncTestFeature.Msg)79            states should containExactly(SyncTestFeature.State(0))80        }81    }82})83private fun createTestFeature() = SyncFeature(SyncTestFeature.State(0), SyncTestFeature::reducer)84private object SyncTestFeature {85    fun reducer(msg: Msg, state: State): Pair<State, Set<Eff>> =86        state.copy(counter = state.counter + 1) to setOf(Eff)87    object Msg88    object Eff89    data class State(val counter: Int)90}...

PackageReferenceTest.kt

Source:PackageReferenceTest.kt

...18 */19package org.ossreviewtoolkit.model20import io.kotest.core.spec.style.WordSpec21import io.kotest.matchers.collections.beEmpty22import io.kotest.matchers.collections.containExactly23import io.kotest.matchers.collections.haveSize24import io.kotest.matchers.should25import io.kotest.matchers.shouldBe26import io.kotest.matchers.string.endWith27class PackageReferenceTest : WordSpec() {28    companion object {29        fun pkgRefFromIdStr(id: String, vararg dependencies: PackageReference) =30            PackageReference(Identifier(id), dependencies = dependencies.toSortedSet())31    }32    private val node111 = pkgRefFromIdStr("::node1_1_1")33    private val node11 = pkgRefFromIdStr("::node1_1", node111)34    private val node12 = pkgRefFromIdStr("::node1_2")35    private val node1 = pkgRefFromIdStr("::node1", node11, node12)36    private val node2 = pkgRefFromIdStr("::node2")37    private val node3 = pkgRefFromIdStr("::node3", node12)38    private val root = pkgRefFromIdStr("::root", node1, node2, node3)39    init {40        "findReferences" should {41            "find references to an existing id" {42                root.findReferences(Identifier("::node1_2")) should containExactly(node12, node12)43                root.findReferences(Identifier("::node1")) should containExactly(node1)44            }45            "find no references to a non-existing id" {46                root.findReferences(Identifier("::nodeX_Y_Z")) should beEmpty()47                root.findReferences(Identifier("")) should beEmpty()48            }49        }50        "traverse" should {51            "visit each node of the tree depth-first" {52                val expectedOrder = mutableListOf(node111, node11, node12, node1, node2, node12, node3, root)53                root.traverse {54                    val expectedNode = expectedOrder.removeAt(0)55                    it shouldBe expectedNode56                    it57                }58                expectedOrder should beEmpty()59            }60            "change nodes as expected" {61                val modifiedTree = root.traverse {62                    val name = "${it.id.name}_suffix"63                    it.copy(64                        id = it.id.copy(name = name),65                        issues = listOf(OrtIssue(source = "test", message = "issue $name"))66                    )67                }68                modifiedTree.traverse {69                    it.id.name should endWith("_suffix")70                    it.issues should haveSize(1)71                    it.issues.first().message shouldBe "issue ${it.id.name}"72                    it73                }74            }75        }76        "visitNodes" should {77            "invoke the code block on the child dependencies" {78                val children = root.visitDependencies { it.toList() }79                children should containExactly(node1, node2, node3)80            }81        }82    }83}...

containExactly.kt

Source:containExactly.kt

...7import io.kotest.matchers.should8import io.kotest.matchers.shouldNot9import kotlin.jvm.JvmName10@JvmName("shouldContainExactly_iterable")11infix fun <T> Iterable<T>?.shouldContainExactly(expected: Iterable<T>) = this?.toList() should containExactly(expected.toList())12@JvmName("shouldContainExactly_array")13infix fun <T> Array<T>?.shouldContainExactly(expected: Array<T>) = this?.asList() should containExactly(*expected)14fun <T> Iterable<T>?.shouldContainExactly(vararg expected: T) = this?.toList() should containExactly(*expected)15fun <T> Array<T>?.shouldContainExactly(vararg expected: T) = this?.asList() should containExactly(*expected)16infix fun <T, C : Collection<T>> C?.shouldContainExactly(expected: C) = this should containExactly(expected)17fun <T> Collection<T>?.shouldContainExactly(vararg expected: T) = this should containExactly(*expected)18fun <T> containExactly(vararg expected: T): Matcher<Collection<T>?> = containExactly(expected.asList())19/** Assert that a collection contains exactly the given values and nothing else, in order. */20fun <T, C : Collection<T>> containExactly(expected: C): Matcher<C?> = neverNullMatcher { actual ->21   val passed = actual.size == expected.size && actual.zip(expected).all { (a, b) -> a == b }22   val failureMessage = {23      val missing = expected.filterNot { actual.contains(it) }24      val extra = actual.filterNot { expected.contains(it) }25      val sb = StringBuilder()26      sb.append("Expecting: ${expected.printed().value} but was: ${actual.printed().value}")27      sb.append("\n")28      if (missing.isNotEmpty()) {29         sb.append("Some elements were missing: ")30         sb.append(missing.printed().value)31         if (extra.isNotEmpty()) {32            sb.append(" and some elements were unexpected: ")33            sb.append(extra.printed().value)34         }35      } else if (extra.isNotEmpty()) {36         sb.append("Some elements were unexpected: ")37         sb.append(extra.printed().value)38      }39      sb.toString()40   }41   MatcherResult(42      passed,43      failureMessage44   ) { "Collection should not be exactly ${expected.printed().value}" }45}46@JvmName("shouldNotContainExactly_iterable")47infix fun <T> Iterable<T>?.shouldNotContainExactly(expected: Iterable<T>) = this?.toList() shouldNot containExactly(expected.toList())48@JvmName("shouldNotContainExactly_array")49infix fun <T> Array<T>?.shouldNotContainExactly(expected: Array<T>) = this?.asList() shouldNot containExactly(*expected)50fun <T> Iterable<T>?.shouldNotContainExactly(vararg expected: T) = this?.toList() shouldNot containExactly(*expected)51fun <T> Array<T>?.shouldNotContainExactly(vararg expected: T) = this?.asList() shouldNot containExactly(*expected)52infix fun <T, C : Collection<T>> C?.shouldNotContainExactly(expected: C) = this shouldNot containExactly(expected)53fun <T> Collection<T>?.shouldNotContainExactly(vararg expected: T) = this shouldNot containExactly(*expected)54fun <T, C : Collection<T>> C.printed(): Printed {55   val expectedPrinted = take(20).joinToString(",\n  ", prefix = "[\n  ", postfix = "\n]") { it.show().value }56   val expectedMore = if (size > 20) " ... (plus ${size - 20} more)" else ""57   return Printed("$expectedPrinted$expectedMore")58}...

TextChannelTests.kt

Source:TextChannelTests.kt

...7import dev.discordkt.models.permissions.Permission8import dev.discordkt.snowflake.Snowflake9import io.kotest.core.spec.style.StringSpec10import io.kotest.matchers.collections.beEmpty11import io.kotest.matchers.collections.containExactly12import io.kotest.matchers.should13import io.kotest.matchers.shouldBe14class TextChannelTests : StringSpec({15    "Text Channel With Perms" {16        """{17  "id": "761287705354567680",18  "last_message_id": "762021898447487038",19  "type": 0,20  "name": "githook",21  "position": 21,22  "parent_id": null,23  "topic": null,24  "guild_id": "455265814191276037",25  "permission_overwrites": [],26  "nsfw": false,27  "rate_limit_per_user": 028}29""".deserializes<Channel> {30            it.longId shouldBe 761287705354567680L31            it.lastMessageId?.longId shouldBe 762021898447487038L32            it.type shouldBe ChannelType.GUILD_TEXT33            it.name shouldBe "githook"34            it.position shouldBe 2135            it.parentId shouldBe null36            it.topic shouldBe null37            it.guildId?.longId shouldBe 455265814191276037L38            it.permissionOverwrites!! should beEmpty()39            it.nsfw shouldBe false40            it.rateLimitPerUser shouldBe 041        }42    }43    "Overwrite channel"{44        """{45  "id": "479635335760969748",46  "last_message_id": "504016397509328908",47  "type": 0,48  "name": "test-cazgirl",49  "position": 4,50  "parent_id": "455265814191276038",51  "topic": null,52  "guild_id": "455265814191276037",53  "permission_overwrites": [54    {55      "id": "455265814191276037",56      "type": "role",57      "allow": "0",58      "deny": "1024"59    },60    {61      "id": "467792830786699286",62      "type": "role",63      "allow": "1024",64      "deny": "0"65    }66  ],67  "nsfw": false,68  "rate_limit_per_user": 069}""".deserializes<Channel> {70            it.longId shouldBe 479635335760969748L71            it.lastMessageId?.longId shouldBe 50401639750932890872            it.type shouldBe ChannelType.GUILD_TEXT73            it.name shouldBe "test-cazgirl"74            it.position shouldBe 475            it.parentId?.longId shouldBe 455265814191276038L76            it.topic shouldBe null77            it.guildId?.longId shouldBe 455265814191276037L78            it.permissionOverwrites should containExactly(79                Overwrite(80                    Snowflake.of(455265814191276037L),81                    OverwriteType.ROLE, Permission.BitField(listOf()), Permission.BitField(listOf(Permission.VIEW_CHANNEL))),82                Overwrite(83                    Snowflake.of(467792830786699286L),84                    OverwriteType.ROLE, Permission.BitField(listOf(Permission.VIEW_CHANNEL)), Permission.BitField(listOf())85                )86            )87            it.nsfw shouldBe false88            it.rateLimitPerUser shouldBe 089        }90    }91})...

ActiveStatesTest.kt

Source:ActiveStatesTest.kt

1package ru.nsk.kstatemachine2import io.kotest.core.spec.style.StringSpec3import io.kotest.matchers.collections.containExactly4import io.kotest.matchers.collections.shouldContainExactly5import io.kotest.matchers.should6class ActiveStatesTest : StringSpec({7    "activeStates()" {8        lateinit var state1: State9        lateinit var state2: State10        lateinit var state21: State11        lateinit var state211: State12        val machine = createStateMachine {13            state1 = initialState("state1") {14                transitionOn<SwitchEvent> {15                    targetState = { state2 }16                }17            }18            state2 = state("state2") {19                state21 = initialState("state21") {20                    state211 = addInitialState(createStateMachine(start = false) {21                        // should not be included22                        initialState("state2111")23                    })24                }25            }26        }27        machine.activeStates(true) should containExactly(machine, state1)28        machine.activeStates() should containExactly(state1)29        machine.processEvent(SwitchEvent)30        machine.activeStates(true) should containExactly(machine, state2, state21, state211)31        machine.activeStates() should containExactly(state2, state21, state211)32        state2.activeStates(true) should containExactly(state2, state21, state211)33        state2.activeStates() should containExactly(state21, state211)34    }35    "activeStates() in parallel child mode" {36        lateinit var state1: State37        lateinit var state2: State38        val machine = createStateMachine(childMode = ChildMode.PARALLEL) {39            state1 = state()40            state2 = state()41        }42        machine.activeStates(true) should containExactly(machine, state1, state2)43        machine.activeStates() should containExactly(state1, state2)44    }45    "activeStates() do not include nested machines states" {46        lateinit var initialState: State47        lateinit var nestedMachine: State48        val machine = createStateMachine {49            initialState = initialState {50                nestedMachine = addInitialState(createStateMachine {51                    initialState()52                })53            }54        }55        val s = DefaultState()56        s.recursiveEnterInitialStates()57        machine.activeStates().shouldContainExactly(initialState, nestedMachine)...

UserTest.kt

Source:UserTest.kt

...3import dev.discordkt.models.user.User4import dev.discordkt.models.user.UserFlag5import io.kotest.core.spec.style.StringSpec6import io.kotest.matchers.collections.beEmpty7import io.kotest.matchers.collections.containExactly8import io.kotest.matchers.should9import io.kotest.matchers.shouldBe10class UserTest : StringSpec({11    "User Serialization" {12        """13{14  "id": "80351110224678912",15  "username": "Nelly",16  "discriminator": "1337",17  "avatar": "8342729096ea3675442027381ff50dfe",18  "verified": true,19  "email": "nelly@discord.com",20  "flags": 64,21  "premium_type": 1,22  "public_flags": 6423}24        """.deserializes<User> {25            it.longId shouldBe 80351110224678912L26            it.username shouldBe "Nelly"27            it.discriminator shouldBe "1337"28            it.avatarHash shouldBe "8342729096ea3675442027381ff50dfe"29            it.verified shouldBe true30            it.email shouldBe "nelly@discord.com"31            it.flags should containExactly(UserFlag.HOUSE_BRAVERY)32            it.publicFlags should containExactly(UserFlag.HOUSE_BRAVERY)33            it.premiumType shouldBe PremiumType.NITRO_CLASSIC34        }35        """{"id": "364009534722801665", "username": "Postfix-Bot", "avatar": "8957c49f91481c041d46951a665f8c60", "discriminator": "9450", "public_flags": 0, "flags": 0, "bot": true, "email": null, "verified": true, "locale": "en-US", "mfa_enabled": true}""".deserializes<User> {36            it.longId shouldBe 364009534722801665L37            it.username shouldBe "Postfix-Bot"38            it.avatarHash shouldBe "8957c49f91481c041d46951a665f8c60"39            it.publicFlags!! should beEmpty()40            it.bot shouldBe true41            it.locale shouldBe "en-US"42            it.verified shouldBe true43            it.email shouldBe null44            it.discriminator shouldBe "9450"45        }46    }...

EmojiTest.kt

Source:EmojiTest.kt

1package dev.discordkt.models.emoji2import dev.discordkt.snowflake.Snowflake3import io.kotest.core.spec.style.StringSpec4import io.kotest.matchers.collections.containExactly5import io.kotest.matchers.should6import io.kotest.matchers.shouldBe7import kotlinx.serialization.decodeFromString8import kotlinx.serialization.json.Json9class EmojiTest : StringSpec({10    "should parse" {11        val json = Json {}12        val emojiJsonText = """13            {14              "id": "41771983429993937",15              "name": "LUL",16              "roles": ["41771983429993000", "41771983429993111"],17              "user": {18                "username": "Luigi",19                "discriminator": "0002",20                "id": "96008815106887111",21                "avatar": "5500909a3274e1812beb4e8de6631111"22              },23              "require_colons": true,24              "managed": false,25              "animated": false26            }27        """28        val emoji = json.decodeFromString<Emoji>(emojiJsonText)29        emoji.longId shouldBe 41771983429993937L30        emoji.name shouldBe "LUL"31        emoji.roles should containExactly(32            Snowflake.of(41771983429993000L), Snowflake.of(41771983429993111L)33        )34        emoji.user!!.username shouldBe "Luigi"35        emoji.user!!.discriminator shouldBe "0002"36        emoji.user!!.longId shouldBe 96008815106887111L37        emoji.user!!.avatarHash shouldBe "5500909a3274e1812beb4e8de6631111"38        emoji.requireColons shouldBe true39        emoji.managed shouldBe false40        emoji.animated shouldBe false41    }42})...

containExactly

Using AI Code Generation

1val list = listOf(1, 2, 3, 4, 5)2list should containExactly(1, 2, 3, 4, 5)3val list = listOf(1, 2, 3, 4, 5)4list should containAll(1, 2, 3)5val list = listOf(1, 2, 3, 4, 5)6list should containInAnyOrder(1, 2, 3)

containExactly

Using AI Code Generation

1val list1 = listOf(1, 2, 3)2val list2 = listOf(3, 2, 1)3list1 should containExactly(list2)4val list1 = listOf(1, 2, 3)5val list2 = listOf(3, 2, 1)6list1 should containExactlyInAnyOrder(list2)7val list1 = listOf(1, 2, 3)8val list2 = listOf(3, 2, 1)9list1 should containExactlyInAnyOrder(list2)10val list1 = listOf(1, 2, 3)11val list2 = listOf(3, 2, 1)12list1 should containExactlyInAnyOrder(list2)13val list1 = listOf(1, 2, 3)14val list2 = listOf(3, 2, 1)15list1 should containExactlyInAnyOrder(list2)16val list1 = listOf(1, 2, 3)17val list2 = listOf(3, 2, 1)18list1 should containExactlyInAnyOrder(list2)19val list1 = listOf(1, 2, 3)20val list2 = listOf(3, 2, 1)21list1 should containExactlyInAnyOrder(list2)22val list1 = listOf(1, 2, 3)23val list2 = listOf(3, 2, 1)24list1 should containExactlyInAnyOrder(list2)25val list1 = listOf(1, 2, 3)26val list2 = listOf(3, 2, 1)

containExactly

Using AI Code Generation

1val list = listOf(1, 2, 3)2list should containExactly(1, 2, 3)3list should containExactly(3, 2, 1)4list should containExactly(2, 1, 3)5list should containExactly(1, 2, 3, 4)6list should containExactly(1, 2)7list should containExactly(1, 2, 3, 4, 5)8list should containExactly(1, 2, 3, 4, 5, 6)9list should containExactly(1, 2, 3, 4, 5, 6, 7)10list should containExactly(1, 2, 3, 4, 5, 6, 7, 8)11list should containExactly(1, 2, 3, 4, 5, 6, 7, 8, 9)12list should containExactly(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)13list should containExactly(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)14list should containExactly(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)15list should containExactly(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)16list should containExactly(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)17list should containExactly(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)18list should containExactly(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,

containExactly

Using AI Code Generation

1val list = listOf(1, 2, 3)2list should containExactly(1, 2, 3)3val list = listOf(1, 2, 3)4val list = listOf(1, 2, 3)5val list = listOf(1, 2, 3)6val list = listOf(1, 2, 3)7val list = listOf(1, 2, 3)8val list = listOf(1, 2, 3)9val list = listOf(1, 2, 3)10val list = listOf(1, 2, 3)11val list = listOf(1, 2, 3)12val list = listOf(1, 2, 3)

containExactly

Using AI Code Generation

1import io.kotest.matchers.collections.*2val expectedList = listOf(1, 2, 3)3val actualList = listOf(1, 2, 3)4actualList should containExactly(expectedList)5import io.kotest.matchers.collections.*6val expectedList = listOf(1, 2, 3)7val actualList = listOf(1, 2, 3)8actualList should containExactlyInAnyOrder(expectedList)9import io.kotest.matchers.collections.*10val expectedList = listOf(1, 2, 3)11val actualList = listOf(1, 2, 3)12actualList should containAll(expectedList)13import io.kotest.matchers.collections.*14val expectedList = listOf(1, 2, 3)15val actualList = listOf(1, 2, 3)16actualList should containNone(expectedList)17import io.kotest.matchers.collections.*18val expectedList = listOf(1, 2, 3)19val actualList = listOf(1, 2, 3)20actualList should containSome(expectedList)21import io.kotest.matchers.collections.*22val expectedList = listOf(1, 2, 3)23val actualList = listOf(1, 2, 3)24actualList should contain(expectedList)25import io.kotest.matchers.collections.*26val expectedList = listOf(1, 2, 3)27val actualList = listOf(1, 2, 3)28actualList should containAtLeast(expectedList)29import io.kotest.matchers.collections.*30val expectedList = listOf(1, 2, 3)31val actualList = listOf(1, 2, 3)32actualList should containAtMost(expectedList)

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.