How to use Arb.distinct method of io.kotest.property.arbitrary.distinct class

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

UnitSpec.kt

Source:UnitSpec.kt Github

copy

Full Screen

1package arrow.core.test2import arrow.core.NonEmptyList3import arrow.core.Tuple44import arrow.core.Tuple55import arrow.core.test.generators.unit6import arrow.core.test.laws.Law7import io.kotest.core.names.TestName8import io.kotest.core.spec.style.StringSpec9import io.kotest.property.Arb10import io.kotest.property.Gen11import io.kotest.property.PropertyContext12import io.kotest.property.arbitrary.bind13import io.kotest.property.arbitrary.filter14import io.kotest.property.arbitrary.map15import io.kotest.property.arbitrary.list as KList16import io.kotest.property.arbitrary.map as KMap17import io.kotest.property.checkAll18import kotlin.jvm.JvmOverloads19import kotlin.math.max20/**21 * Base class for unit tests22 */23public abstract class UnitSpec(24 public val iterations: Int = 250,25 public val maxDepth: Int = 15,26 spec: UnitSpec.() -> Unit = {}27) : StringSpec() {28 public constructor(spec: UnitSpec.() -> Unit) : this(250, 15, spec)29 public fun <A> Arb.Companion.list(gen: Gen<A>, range: IntRange = 0..maxDepth): Arb<List<A>> =30 Arb.KList(gen, range)31 public fun <A> Arb.Companion.nonEmptyList(arb: Arb<A>, depth: Int = maxDepth): Arb<NonEmptyList<A>> =32 Arb.list(arb, 1..max(1, depth)).filter(List<A>::isNotEmpty).map(NonEmptyList.Companion::fromListUnsafe)33 public fun <A> Arb.Companion.sequence(arbA: Arb<A>, range: IntRange = 0..maxDepth): Arb<Sequence<A>> =34 Arb.list(arbA, range).map { it.asSequence() }35 @JvmOverloads36 public inline fun <reified A> Arb.Companion.array(gen: Arb<A>, range: IntRange = 0..maxDepth): Arb<Array<A>> =37 Arb.list(gen, range).map { it.toTypedArray() }38 public fun <K, V> Arb.Companion.map(39 keyArb: Arb<K>,40 valueArb: Arb<V>,41 minSize: Int = 1,42 maxSize: Int = 1543 ): Arb<Map<K, V>> =44 Arb.KMap(keyArb, valueArb, minSize = minSize, maxSize = maxSize)45 init {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 )71 public suspend fun <A, B> checkAll(72 genA: Arb<A>,73 genB: Arb<B>,74 property: suspend PropertyContext.(A, B) -> Unit75 ): PropertyContext =76 checkAll(77 iterations,78 genA,79 genB,80 property81 )82 public suspend fun <A, B, C> checkAll(83 genA: Arb<A>,84 genB: Arb<B>,85 genC: Arb<C>,86 property: suspend PropertyContext.(A, B, C) -> Unit87 ): PropertyContext =88 checkAll(89 iterations,90 genA,91 genB,92 genC,93 property94 )95 public suspend fun <A, B, C, D> checkAll(96 genA: Arb<A>,97 genB: Arb<B>,98 genC: Arb<C>,99 genD: Arb<D>,100 property: suspend PropertyContext.(A, B, C, D) -> Unit101 ): PropertyContext =102 checkAll(103 iterations,104 genA,105 genB,106 genC,107 genD,108 property109 )110 public suspend fun <A, B, C, D, E> checkAll(111 genA: Arb<A>,112 genB: Arb<B>,113 genC: Arb<C>,114 genD: Arb<D>,115 genE: Arb<E>,116 property: suspend PropertyContext.(A, B, C, D, E) -> Unit117 ): PropertyContext =118 checkAll(119 iterations,120 genA,121 genB,122 genC,123 genD,124 genE,125 property126 )127 public suspend fun <A, B, C, D, E, F> checkAll(128 genA: Arb<A>,129 genB: Arb<B>,130 genC: Arb<C>,131 genD: Arb<D>,132 genE: Arb<E>,133 genF: Arb<F>,134 property: suspend PropertyContext.(A, B, C, D, E, F) -> Unit135 ): PropertyContext =136 checkAll(137 iterations,138 genA,139 genB,140 genC,141 genD,142 genE,143 genF,144 property145 )146 public suspend fun <A, B, C, D, E, F, G> checkAll(147 gena: Arb<A>,148 genb: Arb<B>,149 genc: Arb<C>,150 gend: Arb<D>,151 gene: Arb<E>,152 genf: Arb<F>,153 geng: Arb<G>,154 fn: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E, f: F, g: G) -> Unit155 ) {156 checkAll(gena, genb, genc, gend, gene, Arb.bind(genf, geng, ::Pair)) { a, b, c, d, e, (f, g) ->157 fn(a, b, c, d, e, f, g)158 }159 }160 public suspend fun <A, B, C, D, E, F, G, H> checkAll(161 gena: Arb<A>,162 genb: Arb<B>,163 genc: Arb<C>,164 gend: Arb<D>,165 gene: Arb<E>,166 genf: Arb<F>,167 geng: Arb<G>,168 genh: Arb<H>,169 fn: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) -> Unit170 ) {171 checkAll(gena, genb, genc, gend, gene, Arb.bind(genf, geng, genh, ::Triple)) { a, b, c, d, e, (f, g, h) ->172 fn(a, b, c, d, e, f, g, h)173 }174 }175 public suspend fun <A, B, C, D, E, F, G, H, I> checkAll(176 gena: Arb<A>,177 genb: Arb<B>,178 genc: Arb<C>,179 gend: Arb<D>,180 gene: Arb<E>,181 genf: Arb<F>,182 geng: Arb<G>,183 genh: Arb<H>,184 geni: Arb<I>,185 fn: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) -> Unit186 ) {187 checkAll(gena, genb, genc, gend, gene, Arb.bind(genf, geng, genh, geni, ::Tuple4)) { a, b, c, d, e, (f, g, h, i) ->188 fn(a, b, c, d, e, f, g, h, i)189 }190 }191 public suspend fun <A, B, C, D, E, F, G, H, I, J> checkAll(192 gena: Arb<A>,193 genb: Arb<B>,194 genc: Arb<C>,195 gend: Arb<D>,196 gene: Arb<E>,197 genf: Arb<F>,198 geng: Arb<G>,199 genh: Arb<H>,200 geni: Arb<I>,201 genj: Arb<J>,202 fn: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J) -> Unit203 ) {204 checkAll(205 gena,206 genb,207 genc,208 gend,209 gene,210 Arb.bind(genf, geng, genh, geni, genj, ::Tuple5)211 ) { a, b, c, d, e, (f, g, h, i, j) ->212 fn(a, b, c, d, e, f, g, h, i, j)213 }214 }215 public suspend fun forFew(216 iterations: Int,217 property: suspend PropertyContext.(Unit) -> Unit218 ): PropertyContext =219 checkAll(220 iterations,221 Arb.unit(),222 property223 )224}...

Full Screen

Full Screen

DynamoRestaurantItemRepositoryTest.kt

Source:DynamoRestaurantItemRepositoryTest.kt Github

copy

Full Screen

1/*2 * Jopiter APP3 * Copyright (C) 2021 Leonardo Colman Lopes4 *5 * This program is free software: you can redistribute it and/or modify6 * it under the terms of the GNU Affero General Public License as published by7 * the Free Software Foundation, either version 3 of the License, or8 * (at your option) any later version.9 *10 * This program is distributed in the hope that it will be useful,11 * but WITHOUT ANY WARRANTY; without even the implied warranty of12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the13 * GNU Affero General Public License for more details.14 *15 * You should have received a copy of the GNU Affero General Public License16 * along with this program. If not, see <https://www.gnu.org/licenses/>.17 */18package repository.dynamo19import app.jopiter.restaurants.model.Period.Dinner20import app.jopiter.restaurants.model.Period.Lunch21import app.jopiter.restaurants.model.RestaurantItem22import app.jopiter.restaurants.model.restaurantItemArb23import app.jopiter.restaurants.repository.dynamo.DynamoRestaurantItemRepository24import app.jopiter.restaurants.repository.dynamo.RestaurantItemEntity25import app.jopiter.restaurants.repository.dynamo.dynamoDbClient26import app.jopiter.restaurants.repository.dynamo.toRestaurantEntity27import app.jopiter.restaurants.repository.dynamo.toRestaurantItem28import br.com.colman.dynamodb.DynamoDbEnhancedClient29import br.com.colman.dynamodb.putItems30import br.com.colman.dynamodb.table31import io.kotest.assertions.timing.eventually32import io.kotest.assertions.withClue33import io.kotest.core.spec.IsolationMode.InstancePerTest34import io.kotest.core.spec.style.ShouldSpec35import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder36import io.kotest.matchers.shouldBe37import io.kotest.property.arbitrary.next38import io.kotest.property.arbitrary.take39import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient40import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable41import kotlin.time.ExperimentalTime42import kotlin.time.seconds43@OptIn(ExperimentalTime::class)44class DynamoRestaurantItemRepositoryTest : ShouldSpec({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()...

Full Screen

Full Screen

StreamSpec.kt

Source:StreamSpec.kt Github

copy

Full Screen

1package arrow.fx.coroutines.stream2import arrow.fx.coroutines.ArrowFxSpec3import arrow.fx.coroutines.suspend4import io.kotest.property.Arb5import io.kotest.property.Shrinker6import io.kotest.property.arbitrary.arb7import io.kotest.property.arbitrary.bind8import io.kotest.property.arbitrary.choice9import io.kotest.property.arbitrary.choose10import io.kotest.property.arbitrary.constant11import io.kotest.property.arbitrary.list12import io.kotest.property.arbitrary.map13import kotlin.math.abs14/**15 * A Spec that allows you to specify depth for all `Arb` used inside the spec.16 *17 * A `Int.Range` of `0..10` is equivalent to `Arb.list` as where it generates `0..100` by default.18 *19 * `Stream` is randomly generated among it's constructors, but it guarantees a depth of maxmimum `10x range.last`.20 * So for `0..10` it will generate at most a `Stream` with `10` `Chunk`s of `10` elements.21 */22abstract class StreamSpec(23 iterations: Int = 350,24 val depth: IntRange = 0..100,25 spec: StreamSpec.() -> Unit = {}26) : ArrowFxSpec(iterations) {27 init {28 spec()29 }30 fun Arb.Companion.long(range: LongRange = Long.MIN_VALUE..Long.MAX_VALUE): Arb<Long> {31 val edgecases = listOf(0L, 1, -1, Long.MAX_VALUE, Long.MIN_VALUE).filter { it in range }32 return arb(LongShrinker(range), edgecases) { it.random.nextLong(range.first, range.last) }33 }34 class LongShrinker(private val range: LongRange) : Shrinker<Long> {35 override fun shrink(value: Long): List<Long> =36 when (value) {37 0L -> emptyList()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 } }57 )58 fun <O> Arb.Companion.stream(59 arb: Arb<O>,60 range: IntRange = depth61 ): Arb<Stream<O>> =62 Arb.choose(63 10 to Arb.list(arb, range).map { os ->64 Stream.iterable(os)65 },66 10 to Arb.list(arb, range).map { os ->67 Stream.iterable(os).unchunk()68 },69 5 to arb.map { fo -> Stream.effect { fo } },70 1 to Arb.bind(Arb.suspended(arb), Arb.list(arb, range), Arb.suspended(Arb.constant(Unit))) { acquire, use, release ->71 Stream.bracketCase(acquire, { _, _ -> release.invoke() }).flatMap { Stream.iterable(use) }72 }73 )74 fun <O> Arb.Companion.suspended(arb: Arb<O>): Arb<suspend () -> O> =75 arb.map { suspend { it.suspend() } }76}...

Full Screen

Full Screen

KeyValueStoreTest.kt

Source:KeyValueStoreTest.kt Github

copy

Full Screen

1package org.example.kv2import io.kotest.common.DelicateKotest3import io.kotest.core.spec.style.shouldSpec4import io.kotest.matchers.nulls.beNull5import io.kotest.matchers.should6import 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}...

Full Screen

Full Screen

IndexTest.kt

Source:IndexTest.kt Github

copy

Full Screen

1package org.example.index2import io.kotest.common.DelicateKotest3import io.kotest.core.spec.style.shouldSpec4import io.kotest.matchers.nulls.beNull5import io.kotest.matchers.should6import 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}...

Full Screen

Full Screen

Task001KtTest.kt

Source:Task001KtTest.kt Github

copy

Full Screen

1import dev.timkante.dcp.containsSumOf2import io.kotest.assertions.withClue3import io.kotest.core.spec.style.StringSpec4import io.kotest.matchers.shouldBe5import io.kotest.property.Arb6import io.kotest.property.arbitrary.int7import io.kotest.property.arbitrary.list8import io.kotest.property.arbitrary.multiples9import io.kotest.property.checkAll10class Task001KtTest : StringSpec({11 "example provided by task" {12 listOf(10, 15, 3, 7) containsSumOf 17 shouldBe true13 }14 "lists with less than two elements can never reach sum" {15 checkAll(Arb.list(gen = Arb.int(), range = 0..1), Arb.int()) { numbers, target ->16 withClue("<$numbers> contains two numbers that add up to <$target>") {17 numbers containsSumOf target shouldBe false18 }19 }20 }21 "sum of exactly two list elements as target yields true" {22 checkAll(Arb.list(gen = Arb.int(), range = 2..2)) { numbers ->23 val target = numbers.sum()24 withClue("<$numbers> add up to <$target>") {25 numbers containsSumOf target shouldBe true26 }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 }46 }47 }48})...

Full Screen

Full Screen

DistinctTest.kt

Source:DistinctTest.kt Github

copy

Full Screen

1package com.sksamuel.kotest.property.arbitrary2import io.kotest.assertions.throwables.shouldThrow3import io.kotest.core.spec.style.FunSpec4import io.kotest.matchers.collections.shouldHaveSize5import io.kotest.matchers.shouldBe6import io.kotest.property.Arb7import io.kotest.property.arbitrary.arbitrary8import io.kotest.property.arbitrary.distinct9import io.kotest.property.arbitrary.int10import io.kotest.property.arbitrary.take11class DistinctTest : FunSpec({12 test("with enough entropy distinct should return required count") {13 Arb.int(0..100000).distinct().take(100).toSet().shouldHaveSize(100)14 }15 test("without enough entropy distinct should throw") {16 shouldThrow<NoSuchElementException> {17 Arb.int(1..9).distinct().take(10).toSet().shouldHaveSize(10)18 }19 }20 test("distinct should honour attempts parameter") {21 var count = 022 val arb = arbitrary {23 count++24 025 }26 shouldThrow<NoSuchElementException> {27 arb.distinct(43).take(2).toSet().shouldHaveSize(2)28 }29 // +1 for the first 0, then +43 for the failures30 count shouldBe 4431 }32 test("distinct should honour attempts == 1") {33 var count = 034 val arb = arbitrary {35 count++36 037 }38 shouldThrow<NoSuchElementException> {39 arb.distinct(1).take(2).toSet().shouldHaveSize(2)40 }41 // +1 for the first 0, then +43 for the failures42 count shouldBe 243 }44})...

Full Screen

Full Screen

MemoryKeyValueStoreSpec.kt

Source:MemoryKeyValueStoreSpec.kt Github

copy

Full Screen

1package org.example.kv2import io.kotest.common.DelicateKotest3import 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})...

Full Screen

Full Screen

Arb.distinct

Using AI Code Generation

copy

Full Screen

1fun <T> Arb<T>.distinct(): Arb<T> = Arb.distinct(this)2fun <T> Arb<T>.distinctBy(f: (T) -> Any): Arb<T> = Arb.distinctBy(this, f)3fun <T, U> Arb<T>.distinctBy(f: (T) -> U, maxRetries: Int): Arb<T> = Arb.distinctBy(this, f, maxRetries)4fun <T> Arb<T>.distinctBy(f: (T) -> Any, maxRetries: Int): Arb<T> = Arb.distinctBy(this, f, maxRetries)5fun <T> Arb<T>.distinctBy(f: (T) -> Any, maxRetries: Int, seed: Long): Arb<T> = Arb.distinctBy(this, f, maxRetries, seed)6fun <T> Arb<T>.distinctBy(f: (T) -> Any, seed: Long): Arb<T> = Arb.distinctBy(this, f, seed)7fun <T> Arb<T>.distinctBy(f: (T) -> Any, maxRetries: Int, seed: Seed): Arb<T> = Arb.distinctBy(this, f, maxRetries, seed)8fun <T> Arb<T>.distinctBy(f: (T) -> Any, seed: Seed): Arb<T> = Arb.distinctBy(this, f, seed)9fun <T, U> Arb<T>.distinctBy(f: (T) -> U, maxRetries: Int, seed: Seed): Arb<T> = Arb.distinctBy(this, f, maxRetries, seed)

Full Screen

Full Screen

Arb.distinct

Using AI Code Generation

copy

Full Screen

1+fun Arb.Companion.distinct(arb: Arb<String>): Arb<String> = arb.distinct()2+fun Arb.Companion.distinct(arb: Arb<Int>): Arb<Int> = arb.distinct()3+fun Arb.Companion.distinct(arb: Arb<Long>): Arb<Long> = arb.distinct()4+fun Arb.Companion.distinct(arb: Arb<Double>): Arb<Double> = arb.distinct()5+fun Arb.Companion.distinct(arb: Arb<Float>): Arb<Float> = arb.distinct()6+fun Arb.Companion.distinct(arb: Arb<Char>): Arb<Char> = arb.distinct()7+fun Arb.Companion.distinct(arb: Arb<Short>): Arb<Short> = arb.distinct()8+fun Arb.Companion.distinct(arb: Arb<Byte>): Arb<Byte> = arb.distinct()9+fun Arb.Companion.distinct(arb: Arb<String>, maxIterations: Int): Arb<String> = arb.distinct(maxIterations)10+fun Arb.Companion.distinct(arb: Arb<Int>, maxIterations: Int): Arb<Int> = arb.distinct(maxIterations)11+fun Arb.Companion.distinct(arb: Arb<Long>, maxIterations: Int): Arb<Long> = arb.distinct(maxIterations)12+fun Arb.Companion.distinct(arb: Arb<Double>, maxIterations: Int): Arb<Double

Full Screen

Full Screen

Arb.distinct

Using AI Code Generation

copy

Full Screen

1import io.kotest.core.spec.style.StringSpec2import io.kotest.matchers.collections.shouldHaveSize3import io.kotest.matchers.shouldBe4import io.kotest.property.Arb5import io.kotest.property.arbitrary.distinct6import io.kotest.property.arbitrary.int7class DistinctTest : StringSpec({8 "distinct" {9 val list = Arb.int().distinct().take(100).toList()10 list.toSet() shouldBe list11 }12})

Full Screen

Full Screen

Arb.distinct

Using AI Code Generation

copy

Full Screen

1val arbInt = Arb.int(1..100).distinct()2val arbInt = Arb.int(1..100).distinct()3val arbInt = Arb.int(1..100).distinct()4val arbInt = Arb.int(1..100).distinct()5val arbInt = Arb.int(1..100).distinct()6val arbInt = Arb.int(1..100).distinct()7val arbInt = Arb.int(1..100).distinct()8val arbInt = Arb.int(1..100).distinct()9val arbInt = Arb.int(1..100).distinct()10val arbInt = Arb.int(1..100).distinct()11val arbInt = Arb.int(1..100).distinct()12val arbInt = Arb.int(1..100).distinct()13val arbInt = Arb.int(1..100).distinct()14val arbInt = Arb.int(1..100).distinct()15val arbInt = Arb.int(1..100).distinct()

Full Screen

Full Screen

Arb.distinct

Using AI Code Generation

copy

Full Screen

1+val distinctInts = Arb.distinct(Arb.int(1..100))2+val distinctInts = Arb.distinct(Arb.int(1..100)) { it % 10 }3+val distinctInts = Arb.distinct(Arb.int(1..100)) { it % 10 }.filter { it > 10 }4+Arb.distinctBy<T, R>(arbitrary: Arb<T>, selector: (T) -> R): Arb<T>5+Arb.distinctBy<T, R>(arbitrary: Arb<T>, selector: (T) -> R, maxRetries: Int): Arb<T>6+val distinctInts = Arb.distinctBy(Arb.int(1..100)) { it % 10 }7+val distinctInts = Arb.distinctBy(Arb.int(1..100)) { it % 10 }.filter { it > 10 }

Full Screen

Full Screen

Arb.distinct

Using AI Code Generation

copy

Full Screen

1+fun distinctNumbers() = Arb.distinct(Arb.int())2+fun distinctNumbersBy() = Arb.distinctBy(Arb.int(), Int::toString)3+fun distinctNumbersUntilChanged() = Arb.distinctUntilChanged(Arb.int())4+fun distinctNumbersUntilChangedBy() = Arb.distinctUntilChangedBy(Arb.int(), Int::toString)5+fun distinctNumbersUntilChangedBy2() = Arb.distinctUntilChangedBy(Arb.int(), { it.toString() })6+fun distinctNumbersUntilChangedBy3() = Arb.distinctUntilChangedBy(Arb.int()) { it.toString() }7+fun distinctNumbersUntilChangedBy4() = Arb.distinctUntilChangedBy(Arb.int(), Int::toString)8+fun distinctNumbersUntilChangedBy5() = Arb.distinctUntilChangedBy(Arb.int()) { it.toString() }9+fun distinctNumbersUntilChangedBy6() = Arb.distinctUntilChangedBy(Arb.int()) { it.toString() }

Full Screen

Full Screen

Arb.distinct

Using AI Code Generation

copy

Full Screen

1data class Person(val name: String, val age: Int)2val distinctNameAndAge = Arb.distinct<Person> { rs, size ->3 Person(Arb.string(1..10).next(rs, size), Arb.int(0..100).next(rs, size))4}5data class Person(val name: String, val age: Int)6val distinctNameAndAge = Arb.distinct<Person> { rs, size ->7 Person(Arb.string(1..10).next(rs, size), Arb.int(0..100).next(rs, size))8}9data class Person(val name: String, val age: Int)10val distinctNameAndAge = Arb.distinct<Person> { rs, size ->11 Person(Arb.string(1..10).next(rs, size), Arb.int(0..100).next(rs, size))12}13data class Person(val name: String, val age: Int)14val distinctNameAndAge = Arb.distinct<Person> { rs, size ->15 Person(Arb.string(1..10).next(rs, size), Arb

Full Screen

Full Screen

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.

LambdaTest Learning Hubs:

YouTube

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

Run Kotest automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

... View sample repo... View DocumentationSign up Free
›
_

Most used method in distinct

Try LambdaTest Now !!

Get 100 minutes of automation test minutes FREE!!

...
Sign up with GoogleSign up with Email
Next-Gen App & Browser Testing Cloud

Was this article helpful?

Helpful

NotHelpful