How to use beUnique method of io.kotest.matchers.collections.unique class

Best Kotest code snippet using io.kotest.matchers.collections.unique.beUnique

matchers.kt

Source:matchers.kt

...110   )111}112fun <T> Iterable<T>.shouldBeUnique() = toList().shouldBeUnique()113fun <T> Array<T>.shouldBeUnique() = asList().shouldBeUnique()114fun <T> Collection<T>.shouldBeUnique() = this should beUnique()115fun <T> Iterable<T>.shouldNotBeUnique() = toList().shouldNotBeUnique()116fun <T> Array<T>.shouldNotBeUnique() = asList().shouldNotBeUnique()117fun <T> Collection<T>.shouldNotBeUnique() = this shouldNot beUnique()118fun <T> beUnique() = object : Matcher<Collection<T>> {119   override fun test(value: Collection<T>) = MatcherResult(120      value.toSet().size == value.size,121      "Collection should be Unique",122      "Collection should contain at least one duplicate element"123   )124}125fun <T> Iterable<T>.shouldContainDuplicates() = toList().shouldContainDuplicates()126fun <T> Array<T>.shouldContainDuplicates() = asList().shouldContainDuplicates()127fun <T> Collection<T>.shouldContainDuplicates() = this should containDuplicates()128fun <T> Iterable<T>.shouldNotContainDuplicates() = toList().shouldNotContainDuplicates()129fun <T> Array<T>.shouldNotContainDuplicates() = asList().shouldNotContainDuplicates()130fun <T> Collection<T>.shouldNotContainDuplicates() = this shouldNot containDuplicates()131fun <T> containDuplicates() = object : Matcher<Collection<T>> {132   override fun test(value: Collection<T>) = MatcherResult(...

UniqueDataProvierIT.kt

Source:UniqueDataProvierIT.kt

1package io.github.serpro69.kfaker2import io.github.serpro69.kfaker.provider.Address3import io.kotest.assertions.assertSoftly4import io.kotest.core.spec.style.DescribeSpec5import io.kotest.matchers.collections.beUnique6import io.kotest.matchers.collections.containDuplicates7import io.kotest.matchers.collections.shouldContainAnyOf8import io.kotest.matchers.collections.shouldNotContainAnyOf9import io.kotest.matchers.should10import io.kotest.matchers.shouldBe11import io.kotest.matchers.shouldNot12import io.kotest.matchers.shouldNotBe13@Suppress("UNCHECKED_CAST")14class UniqueDataProviderIT : DescribeSpec({15    describe("unique generation of values enabled for provider through configuration") {16        val config = FakerConfig.builder().create { uniqueGeneratorRetryLimit = 100 }17        // repeat 10 times to make sure values are not included in the collection18        repeat(10) {19            context("collection of values is generated #run$it") {20                val faker = Faker(config)21                faker.unique.configuration { enable(faker::address) }22                val countries = (0..18).map { faker.address.country() }23                val newCountries = (0..30).map { faker.address.country() }24                it("should have unique values") {25                    assertSoftly {26                        countries should beUnique()27                        newCountries should beUnique()28                        newCountries shouldNotContainAnyOf countries29                    }30                }31            }32        }33    }34    describe("collection of values is used to exclude values from being generated for specific provider") {35        val config = FakerConfig.builder().create { uniqueGeneratorRetryLimit = 100 }36        // repeat 10 times to make sure values are not included in the collection37        repeat(10) {38            val faker = Faker(config)39            faker.unique.configuration { enable(faker::address) }40            val countries = (0..30).map { faker.address.country() }41            context("collection of unique values is generated run#$it") {42                val excludedCountries = listOf(43                    "Afghanistan", "Albania", "Algeria", "American Samoa", "Andorra", "Angola"44                )45                faker.unique.configuration { excludeFromFunction(Address::country, excludedCountries) }46                val newCountries = (0..30).map { faker.address.country() }47                val moreExcludedCountries = listOf(48                    "Cambodia", "Cameroon", "Canada", "Cape Verde", "Cayman Islands", "Central African Republic"49                )50                faker.unique.configuration { excludeFromProvider<Address>(moreExcludedCountries) }51                val moreCountries = (0..30).map { faker.address.country() }52                val excludedCountryCodes = listOf("AD", "AE", "AF", "AG", "AI", "AL", "AM", "AO", "AQ")53                faker.unique.configuration { excludeFromProvider<Address>(excludedCountryCodes) }54                val countryCodes = (0..30).map { faker.address.countryCode() }55                it("excluded values through config should not be included in the generation") {56                    assertSoftly {57                        newCountries shouldNotContainAnyOf excludedCountries58                        moreCountries shouldNotContainAnyOf moreExcludedCountries59                        countryCodes shouldNotContainAnyOf excludedCountryCodes60                    }61                }62                it("already generated values through config should not be included in the generation") {63                    assertSoftly {64                        newCountries shouldNotContainAnyOf countries65                        moreCountries shouldNotContainAnyOf newCountries66                        moreCountries shouldNotContainAnyOf countries67                    }68                }69            }70        }71    }72    describe("use collections to exclude values from being generated for all providers") {73        // repeat 10 times to make sure values are not included in the collection74        repeat(10) {75            val faker = Faker()76            val excludedCountries = listOf(77                "Afghanistan", "Albania", "Algeria", "American Samoa", "Andorra",78                "Angola", "Anguilla", "Antarctica (the territory South of 60 deg S)", "Antigua and Barbuda",79                "Argentina", "Armenia", "Aruba", "Australia", "Austria", "Azerbaijan", "Bahamas", "Bahrain",80                "Bangladesh", "Barbados", "Belarus", "Belgium", "Belize", "Benin", "Bermuda", "Bhutan", "Bolivia",81                "Bosnia and Herzegovina", "Botswana", "Bouvet Island (Bouvetoya)", "Brazil",82                "British Indian Ocean Territory (Chagos Archipelago)", "Brunei Darussalam", "Bulgaria",83                "Burkina Faso", "Burundi", "Cambodia", "Cameroon", "Canada", "Cape Verde", "Cayman Islands",84                "Central African Republic", "Chad", "Chile", "China", "Christmas Island", "Cocos (Keeling) Islands",85                "Colombia", "Comoros", "Congo", "Congo", "Cook Islands", "Costa Rica", "Cote d'Ivoire", "Croatia",86                "Cuba", "Cyprus", "Czech Republic",87            )88            val excludedNames = listOf(89                "Abbott", "Abernathy", "Abshire", "Adams", "Altenwerth", "Anderson", "Ankunding", "Armstrong", "Auer",90                "Aufderhar", "Bahringer", "Bailey", "Balistreri", "Barrows", "Bartell", "Bartoletti", "Barton",91                "Bashirian", "Batz", "Bauch", "Baumbach", "Bayer", "Beahan", "Beatty", "Bechtelar", "Becker", "Bednar",92                "Beer", "Beier", "Berge", "Bergnaum", "Bergstrom", "Bernhard", "Bernier", "Bins", "Blanda", "Blick",93                "Block", "Bode", "Boehm", "Bogan", "Bogisich", "Borer", "Bosco", "Botsford", "Boyer", "Boyle",94                "Bradtke", "Brakus", "Braun", "Breitenberg", "Brekke", "Brown", "Bruen", "Buckridge"95            )96            val excludedBicCodes = listOf(97                "AACCGB21", "AACNGB21", "AAFMGB21", "AAHOGB21", "AAHVGB21", "AANLGB21",98                "AANLGB2L", "AAOGGB21", "AAPEGB21", "AAPUGB21", "AAQIGB21", "ABBYGB2L",99                "BCYPGB2LCBB", "BCYPGB2LHGB", "BCYPGB2LHHB", "BCYPGB2LPGB", "BCYPGB2LSSB", "BCYPGB2LMBB"100            )101            val excludeAll = listOf(excludedCountries, excludedNames, excludedBicCodes).flatten()102            faker.unique.configuration {103                enable(faker::address)104                enable(faker::name)105                exclude(excludeAll)106            }107            context("collection of unique values is generated run#$it") {108                val countries = (0..30).map { faker.address.country() }109                val names = (0..30).map { faker.name.lastName() }110                // Unique generation not enabled for Bank111                val bicCodes = (0..30).map { faker.bank.swiftBic() }112                it("should not contain excluded values") {113                    assertSoftly {114                        countries shouldNotContainAnyOf excludeAll115                        names shouldNotContainAnyOf excludeAll116                        // Unique generation not enabled for Bank117                        bicCodes shouldNot beUnique()118                        bicCodes shouldContainAnyOf  excludedBicCodes119                    }120                }121            }122        }123    }124    describe("use regex patterns to exclude values from being generated for all providers") {125        repeat(10) {126            val faker = Faker()127            faker.unique.configuration {128                // Enable unique generation129                enable(faker::address)130                enable(faker::name)131                // Exclude all values starting with "A"132                exclude { listOf(Regex("^A")) }133            }134            it("should not contain values matching pattern run#$it") {135                val countries = (0..30).map { faker.address.country() }136                val names = (0..30).map { faker.name.lastName() }137                // Unique generation not enabled for Bank138                val bicCodes = (0..30).map { faker.bank.swiftBic() }139                assertSoftly {140                    countries.none { s -> s.startsWith("A") } shouldBe true141                    countries should beUnique()142                    names.none { s -> s.startsWith("A") } shouldBe true143                    names should beUnique()144                    // Unique generation not enabled for Bank145                    bicCodes.any { s -> s.startsWith("A") } shouldBe true146                    bicCodes shouldNot beUnique()147                }148            }149        }150    }151    describe("use regex patterns to exclude values from being generated for specific provider") {152        repeat(10) {153            val faker = Faker()154            faker.unique.configuration {155                // Enable unique generation and exclude by patterns156                enable(faker::address) {157                    excludeFromProvider<Address> { listOf(Regex("^A")) }158                    excludeFromFunction(Address::country) { listOf(Regex("^B")) }159                }160            }161            it("excluded values by pattern should not be included in the generation for the provider run#$it") {162                val countries = (0..30).map { faker.address.country() }163                val cities = (0..30).map { faker.address.city() }164                assertSoftly {165                    countries.none { s -> s.startsWith("A") } shouldBe true166                    countries.none { s -> s.startsWith("B") } shouldBe true167                    cities.none { s -> s.startsWith("A") } shouldBe true168                }169            }170        }171    }172    describe("unique generation of values for category") {173        val config = FakerConfig.builder().create { uniqueGeneratorRetryLimit = 100 }174        context("collection of values is generated") {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                    }371                }372            }373        }374    }375})...

UnitTransformationTest.kt

Source:UnitTransformationTest.kt

...3import de.gleex.pltcmd.game.ui.strings.extensions.toFrontendString4import de.gleex.pltcmd.model.elements.units.Units5import io.kotest.core.spec.style.WordSpec6import io.kotest.inspectors.forAll7import io.kotest.matchers.collections.beUnique8import io.kotest.matchers.should9import io.kotest.matchers.shouldBe10import io.kotest.matchers.string.beUpperCase11import mu.KotlinLogging12private val log = KotlinLogging.logger {}13class UnitTransformationTest : WordSpec() {14    init {15        "The unit transformation" should {16            "work for units and unit blueprints" {17                Format.values()18                        .forAll { format ->19                            Units.values()20                                    .forAll { blueprint ->21                                        val blueprintValue: String = blueprint.toFrontendString(format).value22                                        val unitValue: String = blueprint.new()23                                                .toFrontendString(format).value24                                        blueprintValue shouldBe unitValue25                                    }26                        }27            }28        }29        "The icon for a unit" should {30            Units.values()31                    .groupBy { it.kind }32                    .forEach { (unitKind, blueprints) ->33                        "be unique for unit kind $unitKind" {34                            val icons = blueprints.map { it.toFrontendString(Format.ICON).value }35                            icons.logDuplicates(Format.ICON)36                            icons should beUnique()37                        }38                    }39        }40        "The 3 digit frontend string of all units" should {41            val short3Strings = Units.values()42                    .map { it.toFrontendString(Format.SHORT3).value }43            "be unique" {44                short3Strings.logDuplicates(Format.SHORT3)45                short3Strings should beUnique()46            }47            "be upper case" {48                short3Strings.forAll {49                    it should beUpperCase()50                }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    }...

unique.kt

Source:unique.kt

...11   asList().shouldBeUnique()12   return this13}14fun <T> Collection<T>.shouldBeUnique(): Collection<T> {15   this should beUnique()16   return this17}18fun <T> Iterable<T>.shouldNotBeUnique(): Iterable<T> {19   toList().shouldNotBeUnique()20   return this21}22fun <T> Array<T>.shouldNotBeUnique(): Array<T> {23   asList().shouldNotBeUnique()24   return this25}26fun <T> Collection<T>.shouldNotBeUnique(): Collection<T> {27   this shouldNot beUnique()28   return this29}30fun <T> beUnique() = object : Matcher<Collection<T>> {31   override fun test(value: Collection<T>) = MatcherResult(32      value.toSet().size == value.size,33      { "Collection should be Unique" },34      {35         "Collection should contain at least one duplicate element"36      })37}...

beUnique

Using AI Code Generation

1    import io.kotest.matchers.collections.unique2    val list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)3    list should beUnique()4    import io.kotest.matchers.collections.unique5    val list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)6    list should beUnique()7    import io.kotest.matchers.collections.unique8    val list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)9    list should beUnique()10    import io.kotest.matchers.collections.unique11    val list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)12    list should beUnique()13    import io.kotest.matchers.collections.unique14    val list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)15    list should beUnique()16    import io.kotest.matchers.collections.unique17    val list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)18    list should beUnique()19    import io.kotest.matchers.collections.unique20    val list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)21    list should beUnique()

beUnique

Using AI Code Generation

1val list = listOf(1,2,3,4,5,6,7,8,9,10)2list.shouldBeUnique()3val list = listOf(1,2,3,4,5,6,7,8,9,10,10)4list.shouldNotBeUnique()5val list = listOf(1,2,3,4,5,6,7,8,9,10)6val list2 = listOf(1,2,3,4,5,6,7,8,9,10)7list.shouldHaveSameSizeAs(list2)8val list = listOf(1,2,3,4,5,6,7,8,9,10)9val list2 = listOf(1,2,3,4,5,6,7,8,9)10list.shouldNotHaveSameSizeAs(list2)11val list = listOf(1,2,3,4,5,6,7,8,9,10)12list.shouldHaveSize(10)13val list = listOf(1,2,3,4,5,6,7,8,9,10)14list.shouldNotHaveSize(9)15val list = listOf(1,2,3,4,5,6,7,8,9,10)16list.shouldHaveSizeGreaterThan(9)17val list = listOf(1,2,3,4,5,6,7,8,9,10)18list.shouldNotHaveSizeGreaterThan(10)19val list = listOf(1,2,3,4,5,6,7,8,9,10)

beUnique

Using AI Code Generation

1val list = listOf(1, 2, 3, 4, 5, 5, 6)2list.shouldBeUnique()3val set = setOf(1, 2, 3, 4, 5, 6)4set.shouldBeUnique()5val map = mapOf(1 to "a", 2 to "b", 3 to "c")6map.shouldBeUnique()7val array = arrayOf(1, 2, 3, 4, 5, 5, 6)8array.shouldBeUnique()9val charArray = charArrayOf('a', 'b', 'c', 'd', 'e', 'e', 'f')10charArray.shouldBeUnique()11val byteArray = byteArrayOf(1, 2, 3, 4, 5, 5, 6)12byteArray.shouldBeUnique()13val shortArray = shortArrayOf(1, 2, 3, 4, 5, 5, 6)14shortArray.shouldBeUnique()15val intArray = intArrayOf(1, 2, 3, 4, 5, 5, 6)16intArray.shouldBeUnique()17val longArray = longArrayOf(1, 2, 3, 4, 5, 5, 6)18longArray.shouldBeUnique()19val floatArray = floatArrayOf(1f, 2f, 3f, 4f, 5f, 5f, 6f)20floatArray.shouldBeUnique()

beUnique

Using AI Code Generation

1@DisplayName ( "beUnique" ) @Test fun testUnique () { val list = listOf ( 1 , 1 , 2 , 3 , 3 , 4 , 5 ) list . shouldNotBeUnique () val list2 = listOf ( 1 , 2 , 3 , 4 , 5 ) list2 . shouldBeUnique () }2@DisplayName ( "beEmpty" ) @Test fun testEmpty () { val list = listOf () list . shouldBeEmpty () val list2 = listOf ( 1 , 2 , 3 , 4 , 5 ) list2 . shouldNotBeEmpty () }3@DisplayName ( "beSorted" ) @Test fun testSorted () { val list = listOf ( 1 , 2 , 3 , 4 , 5 ) list . shouldBeSorted () val list2 = listOf ( 5 , 4 , 3 , 2 , 1 ) list2 . shouldNotBeSorted () }4@DisplayName ( "beSortedWith" ) @Test fun testSortedWith () { val list = listOf ( 1 , 2 , 3 , 4 , 5 ) list . shouldBeSortedWith ( compareBy { it }) val list2 = listOf ( 5 , 4 , 3 , 2 , 1 ) list2 . shouldNotBeSortedWith ( compareBy { it }) }5@DisplayName ( "beSortedBy" ) @Test fun testSortedBy () { val list = listOf ( 1 , 2 , 3 , 4 , 5 ) list . shouldBeSortedBy { it } val list2 = listOf ( 5 , 4 , 3 , 2 , 1 ) list2 . shouldNotBeSortedBy { it } }6@DisplayName ( "beSortedByDescending" ) @Test fun testSortedByDescending () { val list = listOf ( 1 , 2 , 3 , 4 ,

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.