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

Copied to Clipboard!

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

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

UniqueDataProvierIT.kt

Source:UniqueDataProvierIT.kt

...175            val faker = Faker(config)176            faker.unique.enable(faker::address)177            faker.unique.enable(faker::ancient)178            val countries = (0..20).map { faker.address.country() }179            it("should not contain duplicates") {180                countries should beUnique()181            }182        }183        context("used values are cleared") {184            val faker = Faker(config).also {185                it.unique.enable(it::address)186            }187            val countries = (0..20).map { faker.address.country() }188            faker.unique.clear(faker::address)189            val newCountries = (0..20).map { faker.address.country() }190            it("new collection should not contain duplicates") {191                newCountries should beUnique()192            }193            it("new collection should not equal old collection") {194                newCountries shouldNotBe countries195            }196        }197        context("exclude values from being generated") {198            // repeat 10 times to make sure values are not included in the collection199            repeat(10) {200                val faker = Faker(config)201                faker.unique.enable(faker::address)202                val countries = (0..5).map { faker.address.country() }203                context("collection of values was marked for exclusion run#$it") {204                    val excludedCountries = listOf(205                        "Afghanistan",206                        "Albania",207                        "Algeria",208                        "American Samoa",209                        "Andorra",210                        "Angola"211                    )212                    faker.unique.exclude<Address>("country", excludedCountries)213                    val newCountries = (0..20).map { faker.address.country() }214                    it("excluded values should not be included in the generation") {215                        newCountries shouldNotContainAnyOf excludedCountries216                    }217                    it("already generated values should not be included in the generation") {218                        newCountries shouldNotContainAnyOf countries219                    }220                }221            }222        }223        context("unique generation is not enabled for category") {224            val faker = Faker(config)225            context("some values were marked for exclusion") {226                val excludedCountries = listOf(227                    "Afghanistan",228                    "Albania",229                    "Algeria",230                    "American Samoa",231                    "Andorra",232                    "Angola",233                    "Anguilla",234                    "Antarctica",235                    "Antigua And Barbuda",236                    "Argentina",237                    "Armenia",238                    "Aruba",239                    "Australia",240                    "Austria",241                    "Aland Islands",242                    "Azerbaijan",243                    "Bahamas",244                    "Bahrain",245                    "Bangladesh",246                    "Barbados",247                    "Belarus",248                    "Belgium",249                    "Belize",250                    "Benin",251                    "Bermuda",252                    "Bhutan",253                    "Bolivia",254                    "Bonaire",255                    "Bosnia And Herzegovina",256                    "Botswana",257                    "Bouvet Island"258                )259                faker.unique.exclude<Address>("country", excludedCountries)260                val countries = (0..100).map { faker.address.country() }261                it("collection can have duplicates") {262                    countries should containDuplicates()263                }264                it("collection can have excluded values") {265                    countries.any { excludedCountries.contains(it) } shouldBe true266                }267            }268        }269        context("values are generated for another category that is not marked for unique generation") {270            val faker = Faker(config)271            faker.unique.enable(faker::address)272            val animalNames = (0..100).map { faker.animal.name() }273            it("collection can have duplicates") {274                animalNames shouldNot beUnique()275            }276        }277        context("unique generation for category is disabled") {278            val faker = Faker(config)279            faker.unique.enable(faker::address)280            (0..20).map { faker.address.country() }281            faker.unique.disable(faker::address)282            context("collection of values is generated") {283                val countries = (0..100).map { faker.address.country() }284                it("collection can have duplicates") {285                    countries shouldNot beUnique()286                }287            }288        }289        context("unique generation is disabled for all categories") {290            val faker = Faker(config)291            faker.unique.enable(faker::address)292            faker.unique.enable(faker::ancient)293            faker.unique.disableAll()294            context("collections of values are generated") {295                val countries = (0..100).map { faker.address.country() }296                val gods = (0..100).map { faker.ancient.god() }297                it("collection can have duplicates") {298                    assertSoftly {299                        countries shouldNot beUnique()300                        gods shouldNot beUnique()301                    }302                }303            }304            context("unique generation for a category is re-enabled") {305                faker.unique.enable(faker::address)306                context("collection of values is generated") {307                    val countries = (0..20).map { faker.address.country() }308                    it("collection should not contain duplicates") {309                        countries should beUnique()310                    }311                }312            }313        }314        context("unique generation is cleared for all categories") {315            val faker = Faker(config)316            faker.unique.enable(faker::address)317            faker.unique.enable(faker::ancient)318            // Generate some values first319            (0..20).map { faker.address.country() }320            (0..20).map { faker.ancient.hero() }321            faker.unique.clearAll()322            context("collections of values are generated") {323                val countries = (0..20).map { faker.address.country() }324                val heroes = (0..20).map { faker.ancient.hero() }325                it("collections should be unique") {326                    assertSoftly {327                        countries should beUnique()328                        heroes should beUnique()329                    }330                }331            }332        }333    }334    describe("local unique generation") {335        val config = FakerConfig.builder().create {336            uniqueGeneratorRetryLimit = 100337        }338        val faker = Faker(config)339        context("unique property prefixes the category function invocation") {340            val countries = (0..20).map {341                faker.address.unique.country()342            }343            it("collection should not contain duplicates") {344                countries should beUnique()345            }346            it("other functions of the same category should not be marked as unique") {347                // This will produce an error if used with `unique` prefix348                // because there is only one value in the dictionary349                (0..10).map { faker.address.defaultCountry() }350            }351            context("values are cleared for the function name") {352                faker.address.unique.clear("country")353                val newCountries = (0..20).map {354                    faker.address.unique.country()355                }356                it("collection should not contain duplicates") {357                    newCountries should beUnique()358                }359            }360            context("values are cleared for all functions") {361                repeat(20) { faker.address.unique.country() }362                repeat(20) { faker.address.unique.state() }363                faker.address.unique.clearAll()364                it("re-generated collections should be unique") {365                    val newCountries = (0..20).map { faker.address.unique.country() }366                    val states = (0..20).map { faker.address.unique.state() }367                    assertSoftly {368                        newCountries should beUnique()369                        states should beUnique()370                    }...

matchers.kt

Source:matchers.kt

...183            listOf(1, 2) shouldContainExactlyInAnyOrder listOf(2, 1) // out-order; not more184            listOf(0, 3, 0, 4, 0).shouldContainInOrder(3, 4) // possible items in between185            listOf(1) shouldNotContainAnyOf listOf(2, 3) // black list186            listOf(1, 2, 3) shouldContainAll listOf(3, 2) // out-order; more187            listOf(1, 2, 3).shouldBeUnique() // no duplicates188            listOf(1, 2, 2).shouldContainDuplicates() // at least one duplicate189            listOf(1, 2).shouldNotHaveElementAt(1, 3)190            listOf(1, 2) shouldStartWith 1191            listOf(1, 2) shouldEndWith 2192            listOf(1, 2) shouldContainAnyOf listOf(2, 3)193            val x = SomeType(1)194            x shouldBeOneOf listOf(x) // by reference/instance195            x shouldBeIn listOf(SomeType(1)) // by equality/structural196            listOf(1, 2, null).shouldContainNull()197            listOf(1) shouldHaveSize 1198            listOf(1).shouldBeSingleton() // size == 1199            listOf(1).shouldBeSingleton {200                it.shouldBeOdd()201            }...

StringIT.kt

Source:StringIT.kt

...28                it("should NOT contain # chars") {29                    faker.string.numerify(sourceString) shouldNotContain "#"30                    faker.string.numerify(sourceString) shouldContain "?"31                }32                it("can have duplicates") {33                    val list = List(1000) { faker.string.numerify(sourceString) }34                    list.distinct().size shouldBeLessThan 100035                }36            }37            context("letterify") {38                it("should NOT contain ? chars") {39                    faker.string.letterify(sourceString) shouldNotContain "?"40                    faker.string.letterify(sourceString) shouldContain "#"41                }42                it("can have duplicates") {43                    val list = List(1000) { faker.string.letterify(sourceString) }44                    list.distinct().size shouldBeLessThan 100045                }46                it("should be upper") {47                    faker.string.letterify("###", true) should beUpperCase()48                }49                it("should be lower") {50                    faker.string.letterify("###", false) should beLowerCase()51                }52            }53            context("bothify") {54                it("should NOT contain ? and # chars") {55                    faker.string.bothify(sourceString) shouldNotContain "?"56                    faker.string.bothify(sourceString) shouldNotContain "#"57                }58                it("can have duplicates") {59                    val list = List(1000) { faker.string.bothify("foo#bar?") }60                    list.distinct().size shouldBeLessThan 100061                }62                it("should be upper") {63                    faker.string.bothify("###", true) should beUpperCase()64                }65                it("should be lower") {66                    faker.string.bothify("###", false) should beLowerCase()67                }68            }69            context("regexify") {70                it("should resolve the regex to a string") {71                    faker.string.regexify("""\d{6}""").all { it.isDigit() } shouldBe true72                }73                it("can have duplicates") {74                    val list = List(1000) { faker.string.regexify("""\d\w""") }75                    list.distinct().size shouldBeLessThan 100076                }77            }78        }79        describe("Local unique provider") {80            context("numerify") {81                it("should NOT contain duplicates") {82                    val numerify = List(600) { faker.string.unique.numerify(sourceString) }83                    numerify.distinct().size shouldBe 60084                }85            }86            context("letterify") {87                it("should NOT contain duplicates") {88                    val letterify = List(1000) { faker.string.unique.letterify(sourceString) }89                    letterify.distinct().size shouldBe 100090                }91            }92            context("bothify") {93                it("should NOT contain duplicates") {94                    val bothify = List(10000) { faker.string.unique.bothify(sourceString) }95                    bothify.distinct().size shouldBe 1000096                }97            }98            context("regexify") {99                it("should NOT contain duplicates") {100                    val regexify = List(10000) { faker.string.unique.regexify("""\d{3}\w{3}""") }101                    regexify.distinct().size shouldBe 10000102                }103            }104        }105        describe("Global unique provider") {106            context("excluding values from a function") {107                repeat(100) {108                    it("should not contain excluded values run#$it") {109                        val exclusions = listOf("foo963bar", "foo369bar", "foo666bar")110                        faker.unique.configuration {111                            enable(faker::string)112                            excludeFromFunction<StringProvider>("numerify", exclusions)113                        }...

Nel.kt

Source:Nel.kt

1package io.kotest.assertions.arrow.core2import arrow.core.NonEmptyList3import io.kotest.matchers.collections.shouldBeSorted4import io.kotest.matchers.collections.shouldNotBeSorted5import io.kotest.matchers.collections.shouldBeUnique6import io.kotest.matchers.collections.shouldContain7import io.kotest.matchers.collections.shouldContainAll8import io.kotest.matchers.collections.shouldContainDuplicates9import io.kotest.matchers.collections.shouldContainNoNulls10import io.kotest.matchers.collections.shouldContainNull11import io.kotest.matchers.collections.shouldContainOnlyNulls12import io.kotest.matchers.collections.shouldHaveElementAt13import io.kotest.matchers.collections.shouldHaveSingleElement14import io.kotest.matchers.collections.shouldHaveSize15import io.kotest.matchers.collections.shouldNotHaveSize16import io.kotest.matchers.collections.shouldNotBeUnique17import io.kotest.matchers.collections.shouldNotContain18import io.kotest.matchers.collections.shouldNotContainAll19import io.kotest.matchers.collections.shouldNotContainDuplicates20import io.kotest.matchers.collections.shouldNotContainNoNulls21import io.kotest.matchers.collections.shouldNotContainNull22import io.kotest.matchers.collections.shouldNotContainOnlyNulls23import io.kotest.matchers.collections.shouldNotHaveElementAt24import io.kotest.matchers.collections.shouldNotHaveSingleElement25public fun <A> NonEmptyList<A>.shouldContainOnlyNulls(): NonEmptyList<A> =26  apply { all.shouldContainOnlyNulls() }27public fun <A> NonEmptyList<A>.shouldNotContainOnlyNulls(): NonEmptyList<A> =28  apply { all.shouldNotContainOnlyNulls() }29public fun <A> NonEmptyList<A>.shouldContainNull(): NonEmptyList<A> =30  apply { all.shouldContainNull() }31public fun <A> NonEmptyList<A>.shouldNotContainNull(): NonEmptyList<A> =32  apply { all.shouldNotContainNull() }33public fun <A> NonEmptyList<A>.shouldHaveElementAt(index: Int, element: A): Unit =34  all.shouldHaveElementAt(index, element)35public fun <A> NonEmptyList<A>.shouldNotHaveElementAt(index: Int, element: A): Unit =36  all.shouldNotHaveElementAt(index, element)37public fun <A> NonEmptyList<A>.shouldContainNoNulls(): NonEmptyList<A> =38  apply { all.shouldContainNoNulls() }39public fun <A> NonEmptyList<A>.shouldNotContainNoNulls(): NonEmptyList<A> =40  apply { all.shouldNotContainNoNulls() }41public infix fun <A> NonEmptyList<A>.shouldContain(a: A): Unit {42  all.shouldContain(a)43}44public infix fun <A> NonEmptyList<A>.shouldNotContain(a: A): Unit {45  all.shouldNotContain(a)46}47public fun <A> NonEmptyList<A>.shouldBeUnique(): NonEmptyList<A> =48  apply { all.shouldBeUnique() }49public fun <A> NonEmptyList<A>.shouldNotBeUnique(): NonEmptyList<A> =50  apply { all.shouldNotBeUnique() }51public fun <A> NonEmptyList<A>.shouldContainDuplicates(): NonEmptyList<A> =52  apply { all.shouldContainDuplicates() }53public fun <A> NonEmptyList<A>.shouldNotContainDuplicates(): NonEmptyList<A> =54  apply { all.shouldNotContainDuplicates() }55public fun <A> NonEmptyList<A>.shouldContainAll(vararg ts: A): Unit =56  all.shouldContainAll(*ts)57public fun <A> NonEmptyList<A>.shouldNotContainAll(vararg ts: A): Unit =58  all.shouldNotContainAll(*ts)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() }...

WordGeneratorSpec.kt

Source:WordGeneratorSpec.kt

1/*2 * Copyright 2022 Leonardo Colman Lopes, Luiz Neves Porto3 *4 * Licensed under the Apache License, Version 2.0 (the "License");5 * you may not use this file except in compliance with the License.6 * You may obtain a copy of the License at7 *8 *     http://www.apache.org/licenses/LICENSE-2.09 *10 * Unless required by applicable law or agreed to in writing, software11 * distributed under the License is distributed on an "AS IS" BASIS,12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either press or implied.13 * See the License for the specific language governing permissions and14 * limitations under the License.15 */16@file:Suppress("RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS")17package br.com.colman.passphrase18import io.kotest.assertions.throwables.shouldNotThrowAny19import io.kotest.assertions.throwables.shouldThrowAny20import io.kotest.core.spec.style.FunSpec21import io.kotest.inspectors.forAll22import io.kotest.matchers.collections.shouldContainAll23import io.kotest.matchers.collections.shouldHaveSize24import io.kotest.matchers.collections.shouldNotContainDuplicates25import io.kotest.matchers.shouldBe26import io.kotest.matchers.types.shouldBeInstanceOf27import io.kotest.property.Arb28import io.kotest.property.arbitrary.int29import io.kotest.property.checkAll30import java.security.SecureRandom31import kotlin.random.Random32import java.lang.ClassLoader.getSystemResourceAsStream as resource33class WordGeneratorSpec : FunSpec({34  context("Word list") {35    test("Default word list to EFF big word list") {36      val wordlist = resource("eff_large_wordlist.txt").bufferedReader().readLines()37      BigWordList shouldBe wordlist38      WordGenerator.words shouldBe wordlist39    }40  }41  context("Word generator") {42    val target = WordGenerator43    test("Generates exactly how many words I expect") {44      target.generateWords(5) shouldHaveSize 545      target.generateWords(1) shouldHaveSize 146    }47    test("Generates 3 words by default") {48      target.generateWords() shouldHaveSize 349    }50    test("Generates words only from wordlist") {51      val generatedWords = List(1000) { target.generateWords(100) }.flatten()52      WordGenerator.words shouldContainAll generatedWords53    }54    test("Doesn't repeat words in the same generation") {55      val generatedLists = List(1000) { target.generateWords(1000) }56      generatedLists.forAll {57        it.shouldNotContainDuplicates()58      }59    }60    test("Doesn't exhaust word pool when running multiple times") {61      shouldNotThrowAny {62        List(WordGenerator.words.size) { target.generateWords(WordGenerator.words.size) }63      }64    }65    test("Throws an exception when trying to generate < 1 word") {66      Arb.int(max = 0).checkAll {67        shouldThrowAny { target.generateWords(it) }68      }69    }70    test("Throws an exception if trying to generate more words than available") {71      shouldThrowAny { target.generateWords(target.words.size + 1) }72    }73  }74  context("Generator constructor function") {75    test("Uses the list passed as argument") {76      val arg = listOf("a")77      val gen = WordGenerator(arg)78      gen.words shouldBe arg79    }80    test("Has BigWordList as the default word list") {81      val gen = WordGenerator()82      gen.words shouldBe BigWordList83    }84  }85  context("Random number generation") {86    test("Uses the provided random as numbers source") {87      val lists = List(1000) { WordGenerator(random = Random(1)).generateWords(100) }88      lists.forAll {89        it shouldBe lists.first()90      }91    }92  }93})...

UnitTransformationTest.kt

Source:UnitTransformationTest.kt

...51            }52        }53    }54    private fun Collection<String>.logDuplicates(format: Format) {55        val duplicates = this.duplicates()56        if(duplicates.isNotEmpty()) {57            log.warn { "Non unique $format values: $duplicates" }58        }59    }60    private fun Collection<String>.duplicates(): Set<String> {61        var prev = sorted().first()62        return sorted().drop(1).filter {63            val isDuplicate = it == prev64            prev = it65            isDuplicate66        }.toSet()67    }68}...

OrganizationChecker.kt

Source:OrganizationChecker.kt

...27            throw Exception("Organizations with duplicated names found: $duplicatedNames")28        }29    }30    private fun List<Organization>.checkSerialNumberDuplicates() {31        val duplicates = flatMap { org -> org.counters.map { org to it } }32            .groupBy { (org, counter) -> counter.serialNumber }33            .filter { it.value.size > 1 }34            .map { it.value.map { (org, counter) -> org.name to counter.serialNumber } }35        if (duplicates.isNotEmpty()) {36            throw Exception("Duplicated serial numbers found: $duplicates")37        }38    }39    @JvmName("checkSerialNumberDuplicatesOnListOfRecords")40    fun List<OrganizationsWithStructureXlsReader.OrganizationCounterReadingRecord>.checkSerialNumberDuplicates() {41        val duplicates = groupBy { it.serialNumber }42            .filter { it.value.size > 1 }43            .map { it.key }44        if (duplicates.isNotEmpty()) {45            throw Exception("Organizations with duplicated names found: $duplicates")46        }47    }48}...

ValuedEnumLaws.kt

Source:ValuedEnumLaws.kt

1package org.tesserakt.diskordin.util.enums2import io.kotest.core.spec.style.FreeSpec3import io.kotest.core.spec.style.stringSpec4import io.kotest.inspectors.forAll5import io.kotest.matchers.booleans.shouldBeTrue6import io.kotest.matchers.collections.shouldNotContainDuplicates7import io.kotest.matchers.longs.shouldBeLessThanOrEqual8import org.tesserakt.diskordin.core.data.Permission9import org.tesserakt.diskordin.core.entity.IUser10import org.tesserakt.diskordin.core.entity.`object`.IActivity11import org.tesserakt.diskordin.gateway.shard.Intents12import org.tesserakt.diskordin.impl.util.typeclass.numeric13import org.tesserakt.diskordin.util.typeclass.Numeric14import java.util.*15class ValuedEnumLaws : FreeSpec({16    include("Permissions ", Long.numeric().testValuedEnum<Permission, Long>())17    include("Intents ", Short.numeric().testValuedEnum<Intents, Short>())18    include("User.Flags ", Int.numeric().testValuedEnum<IUser.Flags, Int>())19    include("Activity.Flags ", Short.numeric().testValuedEnum<IActivity.Flags, Short>())20})21fun <N> Numeric<N>.isPowerOf2(n: N): Boolean {22    tailrec fun f(init: N, input: N): Boolean = when {23        init > input -> false24        init < input -> f(init * 2.fromInt(), input)25        else -> true26    }27    return f(1.fromInt(), n)28}29inline fun <reified E, N : Any> Numeric<N>.testValuedEnum() where E : Enum<E>, E : IValued<E, N> = stringSpec {30    "All values should be power of two" {31        EnumSet.allOf(E::class.java)32            .map { it.code }.forAll { isPowerOf2(it).shouldBeTrue() }33    }34    "Sum of all codes should be less then MAX_VALUE" {35        EnumSet.allOf(E::class.java).map { it.code }36            .fold(zero) { acc, i -> acc + i }.toLong() shouldBeLessThanOrEqual maxValue.toLong()37    }38    "All values should be unique" {39        EnumSet.allOf(E::class.java).map { it.code }.shouldNotContainDuplicates()40    }41}...

duplicates

Using AI Code Generation

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

duplicates

Using AI Code Generation

1val list = listOf(1, 2, 3, 4, 5, 5, 6, 6, 7, 7, 8, 8, 8)2list should haveDuplicates()3list should not haveDuplicates()4val list = listOf(1, 2, 3, 4, 5, 5, 6, 6, 7, 7, 8, 8, 8)5list should haveDuplicates()6list should not haveDuplicates()

duplicates

Using AI Code Generation

1val list = listOf(1, 2, 3, 4, 5, 5)2val list = listOf(1, 2, 3, 4, 5, 5)3val map = mapOf("a" to 1, "b" to 2, "c" to 3)4val set = setOf(1, 2, 3, 4, 5, 5)5val list = listOf(1, 2, 3, 4, 5, 5)6val map = mapOf("a" to 1, "b" to 2, "c" to 3)7val set = setOf(1, 2, 3, 4, 5, 5)8val list = listOf(1, 2, 3, 4, 5, 5)9val map = mapOf("a" to 1, "b" to 2, "c" to 3)10val set = setOf(1, 2, 3, 4, 5,

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.