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

Copied to Clipboard!

How to use distinct class of io.kotest.property.arbitrary package

Best Kotest code snippet using io.kotest.property.arbitrary.distinct

UnitSpec.kt

Source:UnitSpec.kt

...46    spec()47  }48  public fun testLaws(vararg laws: List<Law>): Unit = laws49    .flatMap { list: List<Law> -> list.asIterable() }50    .distinctBy { law: Law -> law.name }51    .forEach { law: Law ->52      registration().addTest(TestName(law.name), xdisabled = false, law.test)53    }54  public fun testLaws(prefix: String, vararg laws: List<Law>): Unit = laws55    .flatMap { list: List<Law> -> list.asIterable() }56    .distinctBy { law: Law -> law.name }57    .forEach { law: Law ->58      registration().addTest(TestName(prefix, law.name, true), xdisabled = false, law.test)59    }60  public suspend fun checkAll(property: suspend PropertyContext.() -> Unit): PropertyContext =61    checkAll(iterations, Arb.unit()) { property() }62  public suspend fun <A> checkAll(63    genA: Arb<A>,64    property: suspend PropertyContext.(A) -> Unit65  ): PropertyContext =66    checkAll(67      iterations,68      genA,69      property70    )...

DynamoRestaurantItemRepositoryTest.kt

Source:DynamoRestaurantItemRepositoryTest.kt

...45    val client = DynamoDbEnhancedClient(dynamoDbClient)46    val table = client.table<RestaurantItemEntity>("restaurants")47    val target = DynamoRestaurantItemRepository(client)48    should("Retrieve items present in the table") {49        val items = table.createItems().distinct()50        eventually(20.seconds) {51            val result = items.flatMap { target.get(it.restaurantId, it.date) }.distinct()52            result shouldContainExactlyInAnyOrder items53        }54    }55    should("Retrieve items only from particular dates") {56        val items = table.createItems()57        val result = target.get(1, items[0].date)58        val itemsFromDate = items.filter { it.date == items[0].date && it.restaurantId == 1 }59        result shouldContainExactlyInAnyOrder itemsFromDate60    }61    should("Retrieve items from both periods for a given restaurant") {62        val item1 = restaurantItemArb.next()63        val item2 = item1.copy(period = if(item1.period == Lunch) Dinner else Lunch)64        table.putItems(item1.toRestaurantEntity(), item2.toRestaurantEntity())65        target.get(item1.restaurantId, item1.date) shouldBe setOf(item1, item2)66    }67    should("Save items to table") {68        val items = restaurantItemArb.take(2).toSet()69        target.put(items)70        table.scan().items().map { it.toRestaurantItem() } shouldContainExactlyInAnyOrder items71    }72    beforeTest { client.createTable() }73    isolationMode = InstancePerTest74})75private fun DynamoDbTable<RestaurantItemEntity>.createItems(amount: Int = 200): List<RestaurantItem> {76    val items = restaurantItemArb.take(amount).toList()77    val databaseItems = items.distinctBy { it.restaurantId to it.date }.map { it.toRestaurantEntity() }78    putItems(databaseItems)79    return items80}81private fun DynamoDbEnhancedClient.createTable() = table<RestaurantItemEntity>("restaurants").createTable()...

StreamSpec.kt

Source:StreamSpec.kt

...38        1L, -1L -> listOf(0)39        else -> {40          val a = listOf(abs(value), value / 3, value / 2, value * 2 / 3)41          val b = (1..5L).map { value - it }.reversed().filter { it > 0 }42          (a + b).distinct().filter { it in range && it != value }43        }44      }45  }46  inline fun <reified O, R> Arb.Companion.pull(47    arbO: Arb<O>,48    arbR: Arb<R>,49    range: IntRange = depth50  ): Arb<Pull<O, R>> =51    Arb.choice<Pull<O, R>>(52      Arb.bind(Arb.stream(arbO, range), arbR) { s, r ->53        s.asPull().map { r }54      },55      arbR.map { Pull.just(it) } as Arb<Pull<O, R>>,56      arbR.map { Pull.effect { it } }...

KeyValueStoreTest.kt

Source:KeyValueStoreTest.kt

...6import io.kotest.matchers.shouldBe7import io.kotest.property.Arb8import io.kotest.property.Gen9import io.kotest.property.PropTestConfig10import io.kotest.property.arbitrary.distinct11import io.kotest.property.arbitrary.next12import io.kotest.property.checkAll13import org.example.defaultPropTestConfig14@DelicateKotest15fun <K, V> keyValueStoreTests(16    gen: Gen<KeyValueStore<K, V>>,17    keyGen: Arb<K>,18    valueGen: Arb<V>,19    config: PropTestConfig = defaultPropTestConfig,20) = shouldSpec {21    should("absent key") {22        checkAll(config, gen) { kv ->23            val key = keyGen.next()24            kv[key] should beNull()25            (key in kv) shouldBe false26        }27    }28    should("written value should be readable") {29        checkAll(config, gen) { kv ->30            val key = keyGen.next()31            val expected = valueGen.next()32            kv[key] = expected33            kv[key] shouldBe expected34            (key in kv) shouldBe true35        }36    }37    should("multiple keys are isolated") {38        checkAll(config, gen) { kv ->39            val entries = (0..5).associate { Pair(keyGen.next(), valueGen.next()) }40            kv.putAll(entries)41            for (entry in entries) {42                kv[entry.key] shouldBe entry.value43                (entry.key in kv) shouldBe true44            }45        }46    }47    should("key update") {48        checkAll(config, gen) { kv ->49            val key = keyGen.next()50            val old = valueGen.next()51            val new = valueGen.next()52            kv[key] = old53            kv[key] = new54            kv[key] shouldBe new55            (key in kv) shouldBe true56        }57    }58    should("deleted key becomes absent") {59        checkAll(config, gen) { kv ->60            val distinctKeyGen = keyGen.distinct()61            val key1 = distinctKeyGen.next()62            val value1 = valueGen.next()63            val key2 = distinctKeyGen.next()64            val value2 = valueGen.next()65            kv[key1] = value166            kv[key2] = value267            kv.delete(key1)68            kv[key1] should beNull()69            kv[key2] shouldBe value270            (key1 in kv) shouldBe false71            (key2 in kv) shouldBe true72        }73    }74}...

IndexTest.kt

Source:IndexTest.kt

...6import io.kotest.matchers.shouldBe7import io.kotest.property.Arb8import io.kotest.property.Gen9import io.kotest.property.PropTestConfig10import io.kotest.property.arbitrary.distinct11import io.kotest.property.arbitrary.next12import io.kotest.property.checkAll13import org.example.defaultPropTestConfig14import org.example.randomSource15@DelicateKotest16fun <K> indexTests(17    indices: Gen<Index<K>>,18    keyGen: Arb<K>,19    config: PropTestConfig = defaultPropTestConfig,20) = shouldSpec {21    val rs = config.randomSource()22    should("offsets are persisted") {23        checkAll(config, indices) { index ->24            val key = keyGen.next(rs)25            val expected = 1234L26            index[key] = expected27            index[key] shouldBe expected28        }29    }30    should("absent entry has no offset") {31        checkAll(config, indices) { index ->32            index[keyGen.next(rs)] should beNull()33        }34    }35    should("reads do not delete entries") {36        checkAll(config, indices) { index ->37            val key = keyGen.next(rs)38            val expected = 1234L39            index[key] = expected40            index[key] shouldBe expected41            // second read makes sure that the value is still there42            index[key] shouldBe expected43        }44    }45    should("sequential writes act as updates") {46        checkAll(config, indices) { index ->47            val key = keyGen.next(rs)48            val expected = 4321L49            index[key] = 1234L50            index[key] = expected51            index[key] shouldBe expected52        }53    }54    should("keys are isolated") {55        checkAll(config, indices) { index ->56            val distinctKeyGen = keyGen.distinct()57            val key1 = distinctKeyGen.next(rs)58            val value1 = 1234L59            val key2 = distinctKeyGen.next(rs)60            val value2 = 4321L61            index[key1] = value162            index[key2] = value263            index[key1] shouldBe value164            index[key2] shouldBe value265        }66    }67}...

Task001KtTest.kt

Source:Task001KtTest.kt

...27        }28    }29    "sum of two random list elements as target yields true" {30        checkAll(Arb.list(gen = Arb.int(), range = 2..15)) { numbers ->31            val target = numbers.asSequence().distinct().shuffled().take(2).sum()32            withClue("<$numbers> contains two elements that add up to <$target>") {33                numbers containsSumOf target shouldBe true34            }35        }36    }37    "a list of even numbers can never reach an uneven sum" {38        checkAll(39            Arb.list(gen = Arb.multiples(2, Int.MAX_VALUE), range = 2..15),40            Arb.multiples(k = 2, max = Int.MAX_VALUE)41        ) { numbers, randomEven ->42            val target = randomEven - 143            withClue("<$numbers> contains two elements that add up to <$target>") {44                numbers containsSumOf target shouldBe false45            }...

PadKtTest.kt

Source:PadKtTest.kt

...14        emptyList<Char>().pad({ (it + 97).toChar() }, { it.toInt() - 97 }) shouldBe emptyList()15    }16    "List.pad the size of the returned list is equal to the input list" {17        checkAll(Arb.list(Arb.int(0 until 1000))) { l ->18            l.sorted().distinct().pad(::identity, ::identity).size shouldBeExactly (l.max()?.inc() ?: 0)19        }20    }21})...

MemoryKeyValueStoreSpec.kt

Source:MemoryKeyValueStoreSpec.kt

...3import io.kotest.core.spec.style.ShouldSpec4import io.kotest.property.Arb5import io.kotest.property.PropTestConfig6import io.kotest.property.arbitrary.arbitrary7import io.kotest.property.arbitrary.distinct8import io.kotest.property.arbitrary.string9@DelicateKotest10internal class MemoryKeyValueStoreSpec: ShouldSpec({11    val stringArb = Arb.string().distinct()12    include(factory = keyValueStoreTests(13        arbitrary { MemoryKeyValueStore() },14        stringArb,15        stringArb,16        PropTestConfig(maxFailure = 3, iterations = 1),17    ))18})...

distinct

Using AI Code Generation

1import io.kotest.property.arbitrary.int2import io.kotest.property.arbitrary.string3import io.kotest.property.arbitrary.withEdgecases4import io.kotest.property.arbitrary.withShrinker5import io.kotest.property.arbitrary.withTries6import io.kotest.property.arbitrary.withoutNulls7import io.kotest.matchers.string.shouldContain8import io.kotest.matchers.string.shouldContainOnlyDigits9import io.kotest.matchers.string.shouldContainOnlyOnce10import io.kotest.matchers.string.shouldEndWith11import io.kotest.matchers.string.shouldHaveLength12import io.kotest.matchers.string.shouldHaveLineCount13import io.kotest.matchers.string.shouldHaveSameLengthAs14import io.kotest.matchers.string.shouldHaveSize15import io.kotest.matchers.string.shouldHaveSubstring16import io.kotest.matchers.string.shouldHaveTrimmedLength17import io.kotest.matchers.string.shouldHaveTrimmedSize18import io.kotest.matchers.string.shouldMatch19import io.kotest.matchers.string.shouldNotContain20import io.kotest.matchers.string.shouldNotContainOnlyDigits21import io.kotest.matchers.string.shouldNotContainOnlyOnce22import io.kotest.matchers.string.shouldNotEndWith23import io.kotest.matchers.string.shouldNotHaveLineCount24import io.kotest.matchers.string.shouldNotHaveSubstring25import io.kotest.matchers.string.shouldNotMatch26import io.kotest.matchers.string.shouldNotStartWith27import io.kotest.matchers.string.shouldStartWith28import io.kotest.matchers.numbers.beGreaterThan29import io.kotest.matchers.numbers.beGreaterThanOrEqualTo30import io.kotest.matchers.numbers.beLessThan31import io.kotest.matchers.numbers.beLessThanOrEqualTo32import io.kotest.matchers.numbers.beNegative33import io.kotest.matchers.numbers.bePositive34import io.kotest.matchers.numbers.beZero35import io.kotest.matchers.numbers.greaterThan36import io.kotest.matchers.numbers.greaterThanOrEqual37import io.kotest.matchers.numbers.lessThan38import

distinct

Using AI Code Generation

1import io.kotest.property.arbitrary.*2import io.kotest.property.arbitrary.int3import io.kotest.property.arbitrary.string4import io.kotest.property.arbitrary.uuid5import io.kotest.property.checkAll6import io.kotest.property.exhaustive.exhaustive7import io.kotest.property.exhaustive.ints8import io.kotest.property.exhaustive.string9import io.kotest.property.exhaustive.uuids10import org.junit.jupiter.api.Test11import java.util.*12class PropertyTest {13    fun `should generate random string`() {14        checkAll<String> { str ->15            println(str)16        }17    }18    fun `should generate random int`() {19        checkAll<Int> { i ->20            println(i)21        }22    }23    fun `should generate random uuid`() {24        checkAll<UUID> { uuid ->25            println(uuid)26        }27    }28    fun `should generate random string with length`() {29        checkAll<String>(Gen.string().ofLength(10)) { str ->30            println(str)31        }32    }33    fun `should generate random int from 1 to 10`() {34        checkAll<Int>(Gen.int().between(1, 10)) { i ->35            println(i)36        }37    }38    fun `should generate random uuid from 1 to 10`() {39        checkAll<UUID>(Gen.uuid().ofLength(10)) { uuid ->40            println(uuid)41        }42    }43    fun `should generate random string with length between 1 to 10`() {44        checkAll<String>(Gen.string().ofLength(1..10)) { str ->45            println(str)46        }47    }48    fun `should generate random int from 1 to 10`() {49        checkAll<Int>(Gen.int().between(1..10)) { i ->50            println(i)51        }52    }53    fun `should generate random uuid from 1 to 10`() {54        checkAll<UUID>(Gen.uuid().ofLength(1..10)) { uuid ->55            println(uuid)56        }57    }58    fun `should generate random string with length between 1 to 10`() {

distinct

Using AI Code Generation

1+import io.kotest.property.arbitrary.*2+import io.kotest.core.spec.style.StringSpec3+import io.kotest.matchers.shouldBe4+class ArbTest : StringSpec({5+    "Arbitrary for 1D array"{6+        val arb = Arb.int().array(10)7+        arb.take(100).forEach { it.size shouldBe 10 }8+    }9+    "Arbitrary for 2D array"{10+        val arb = Arb.int().array(10, 10)11+        arb.take(100).forEach { it.size shouldBe 10 }12+    }13+    "Arbitrary for 3D array"{14+        val arb = Arb.int().array(10, 10, 10)15+        arb.take(100).forEach { it.size shouldBe 10 }16+    }17+    "Arbitrary for 4D array"{18+        val arb = Arb.int().array(10, 10, 10, 10)19+        arb.take(100).forEach { it.size shouldBe 10 }20+    }21+    "Arbitrary for 5D array"{22+        val arb = Arb.int().array(10, 10, 10, 10, 10)23+        arb.take(100).forEach { it.size shouldBe 10 }24+    }25+    "Arbitrary for 6D array"{26+        val arb = Arb.int().array(10, 10, 10, 10, 10, 10)27+        arb.take(100).forEach { it.size shouldBe 10 }28+    }29+    "Arbitrary for 7D array"{30+        val arb = Arb.int().array(10, 10, 10, 10, 10, 10, 10)31+        arb.take(100).forEach { it.size shouldBe 10 }32+    }33+    "Arbitrary for 8D array"{34+        val arb = Arb.int().array(10, 10, 10, 10, 10, 10, 10, 10)35+        arb.take(100).forEach { it.size shouldBe 10 }36+    }37+    "Arbitrary for 9D array"{38+        val arb = Arb.int().array(10, 10,

distinct

Using AI Code Generation

1class PropertyTest : StringSpec() {2    init {3        "Property Test" {4            forAll { a: Int, b: Int ->5            }6        }7        "Property Test with custom generator" {8            forAll(StringGenerator()) { s: String ->9                s.length == s.reversed().length10            }11        }12        "Property Test with custom generator and edgecases" {13            forAll(StringGenerator(), StringGenerator()) { s1: String, s2: String ->14            }15        }16        "Property Test with custom generator and edgecases and config" {17            forAll(10, StringGenerator(), StringGenerator()) { s1: String, s2: String ->18            }19        }20        "Property Test with custom generator and edgecases and config and labels" {21            forAll(10, StringGenerator(), StringGenerator()) { s1: String, s2: String ->22            }.config(invocations = 10).labels("s1", "s2")23        }24        "Property Test with custom generator and edgecases and config and labels and name" {25            forAll(10, StringGenerator(), StringGenerator()) { s1: String, s2: String ->26            }.config(invocations = 10).labels("s1", "s2").name("Custom name")27        }28        "Property Test with custom generator and edgecases and config and labels and name and tags" {29            forAll(10, StringGenerator(), StringGenerator()) { s1: String, s2: String ->30            }.config(invocations = 10).labels("s1", "s2").name("Custom name").tags("tag1", "tag2")31        }32        "Property Test with custom generator and edgecases and config and labels and name and tags and test" {33            forAll(10, StringGenerator(), StringGenerator()) { s1: String, s2: String ->

distinct

Using AI Code Generation

1+import io.kotest.property.arbitrary.*2+import io.kotest.property.arbitrary.distinct3+class DistinctTest : FunSpec({4+   test("distinct should return distinct values") {5+      val gen = int().distinct()6+      gen.take(100).toSet().size shouldBe 1007+   }8+   test("distinct should return distinct values for a given seed") {9+      val gen = int().distinct()10+      gen.take(100).toSet().size shouldBe 10011+      gen.take(100).toSet().size shouldBe 10012+   }13+   test("distinct should return distinct values for a given seed and max") {14+      val gen = int().distinct(10)15+      gen.take(100).toSet().size shouldBe 1016+      gen.take(100).toSet().size shouldBe 1017+   }18+   test("distinct should return distinct values for a given seed and max and min") {19+      val gen = int(1, 10).distinct(10)20+      gen.take(100).toSet().size shouldBe 1021+      gen.take(100).toSet().size shouldBe 1022+   }23+   test("distinct should return distinct values for a given seed and max and min and maxIterations") {24+      val gen = int(1, 10).distinct(10, 1, 1000)25+      gen.take(100).toSet().size shouldBe 1026+      gen.take(100).toSet().size shouldBe 1027+   }28+   test("distinct should return distinct values for a given seed and max and min and maxIterations and maxRetries") {29+      val gen = int(1, 10).distinct(10, 1, 1000, 1000)30+      gen.take(100).toSet().size shouldBe 1031+      gen.take(100).toSet().size shouldBe 1032+   }33+   test("distinct should return distinct values for a given seed and max and min and maxIterations and maxRetries and shrinker") {34+      val gen = int(1, 10).distinct(10, 1, 1000, 1000, Shrinker.default())

distinct

Using AI Code Generation

1import io.kotest.property.arbitrary.*2import io.kotest.property.checkAll3class PropertyTest : StringSpec() {4    init {5        "String should have length >=0" {6            checkAll<String> {7            }8        }9        "String should have length >=0 and should contain substring" {10            checkAll<String, String> { a, b ->11                a.length >= 0 && a.contains(b)12            }13        }14        "String should have length >=0 and should contain substring" {15            checkAll<String, String> { a, b ->16                a.length >= 0 && a.contains(b)17            }18        }19        "String should have length >=0 and should contain substring" {20            checkAll<String, String> { a, b ->21                a.length >= 0 && a.contains(b)22            }23        }24        "String should have length >=0 and should contain substring" {25            checkAll<String, String> { a, b ->26                a.length >= 0 && a.contains(b)27            }28        }29        "String should have length >=0 and should contain substring" {30            checkAll<String, String> { a, b ->31                a.length >= 0 && a.contains(b)32            }33        }34        "String should have length >=0 and should contain substring" {35            checkAll<String, String> { a, b ->36                a.length >= 0 && a.contains(b)37            }38        }39        "String should have length >=0 and should contain substring" {40            checkAll<String, String> { a, b ->41                a.length >= 0 && a.contains(b)42            }43        }44        "String should have length >=0 and should contain substring" {45            checkAll<String, String> { a, b ->46                a.length >= 0 && a.contains(b)47            }48        }49        "String should have length >=0 and should contain substring" {50            checkAll<String, String> { a, b ->51                a.length >= 0 && a.contains(b)52            }53        }54        "String should have length >=0 and should contain substring" {55            checkAll<String, String> { a, b ->56                a.length >= 0 && a.contains(b)57            }58        }59        "String should have length >=0 and should contain substring" {60            checkAll<String, String> { a, b ->

distinct

Using AI Code Generation

1+class DistinctTest : FunSpec({2+   test("distinct") {3+      val gen = Arb.int().distinct()4+      gen.take(100).toList().distinct().size shouldBe 1005+   }6+})7+class DistinctTest : FunSpec({8+   test("distinct") {9+      val gen = Arb.int().distinct()10+      gen.take(100).toList().distinct().size shouldBe 10011+   }12+})13+class DistinctTest : FunSpec({14+   test("distinct") {15+      val gen = Arb.int().distinct()16+      gen.take(100).toList().distinct().size shouldBe 10017+   }18+})19+class DistinctTest : FunSpec({20+   test("distinct") {21+      val gen = Arb.int().distinct()22+      gen.take(100).toList().distinct().size shouldBe 10023+   }24+})25+class DistinctTest : FunSpec({26+   test("distinct") {27+      val gen = Arb.int().distinct()28+      gen.take(100).toList().distinct().size shouldBe 10029+   }30+})31+class DistinctTest : FunSpec({32+   test("distinct") {33+      val gen = Arb.int().distinct()34+      gen.take(100).toList().distinct().size shouldBe 10035+   }36+})37+class DistinctTest : FunSpec({38+   test("distinct") {39+      val gen = Arb.int().distinct()40+      gen.take(100).toList().distinct().size shouldBe 10041+   }42+})43+class DistinctTest : FunSpec({44+   test("distinct") {45+      val gen = Arb.int().distinct()46+      gen.take(100).toList().distinct().size shouldBe 100

distinct

Using AI Code Generation

1fun generateRandomString(): String {2    return Arb.string(10, 20).next()3}4fun generateRandomInt(): Int {5    return Arb.int().next()6}7fun generateRandomLong(): Long {8    return Arb.long().next()9}10fun generateRandomFloat(): Float {11    return Arb.float().next()12}13fun generateRandomDouble(): Double {14    return Arb.double().next()15}16fun generateRandomBoolean(): Boolean {17    return Arb.bool().next()18}19fun generateRandomChar(): Char {20    return Arb.char().next()21}22fun generateRandomListOfString(): List<String> {23    return Arb.list(Arb.string(10, 20)).next()24}25fun generateRandomListOfInt(): List<Int> {26    return Arb.list(Arb.int()).next()27}28fun generateRandomListOfLong(): List<Long> {29    return Arb.list(Arb.long()).next()30}31fun generateRandomListOfFloat(): List<Float> {32    return Arb.list(Arb.float()).next()33}34fun generateRandomListOfDouble(): List<Double> {35    return Arb.list(Arb.double()).next()36}

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.