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

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

Arb.kt

Source:Arb.kt

1package arrow.fx.coroutines.stream2import io.kotest.property.Arb3import io.kotest.property.RandomSource4import io.kotest.property.Sample5import io.kotest.property.Shrinker6import io.kotest.property.arbitrary.arb7import io.kotest.property.arbitrary.bool8import io.kotest.property.arbitrary.byte9import io.kotest.property.arbitrary.choice10import io.kotest.property.arbitrary.choose11import io.kotest.property.arbitrary.double12import io.kotest.property.arbitrary.float13import io.kotest.property.arbitrary.int14import io.kotest.property.arbitrary.list15import io.kotest.property.arbitrary.long16import io.kotest.property.arbitrary.map17import io.kotest.property.arbitrary.set18import io.kotest.property.arbitrary.short19import kotlin.random.nextInt20@JvmOverloads21inline fun <reified A> Arb.Companion.array(22  gen: Arb<A>,23  range: IntRange = 0..10024): Arb<Array<A>> {25  check(!range.isEmpty())26  check(range.first >= 0)27  return arb(edgecases = listOf(emptyArray<A>()) + gen.edgecases().map { arrayOf(it) }) {28    sequence {29      val genIter = gen.generate(it).iterator()30      while (true) {31        val targetSize = it.random.nextInt(range)32        val list = ArrayList<A>(targetSize)33        while (list.size < targetSize && genIter.hasNext()) {34          list.add(genIter.next().value)35        }36        check(list.size == targetSize)37        yield(list.toArray() as Array<A>)38      }39    }40  }41}42@PublishedApi43internal fun <A, B> arrayChunkGenerator(44  arb: Arb<A>,45  shrinker: Shrinker<B>,46  range: IntRange = 0..10,47  build: (values: List<A>, offset: Int, length: Int) -> B48): Arb<B> {49  check(!range.isEmpty())50  check(range.first >= 0)51  val edgecases =52    arb.edgecases().map { a -> build(listOf(a), 0, 1) } + build(emptyList(), 0, 0)53  return arb(edgecases, shrinker) {54    val genIter = arb.generate(it).iterator()55    sequence {56      while (true) {57        val targetSize = it.random.nextInt(range)58        val list = ArrayList<A>(targetSize)59        while (list.size < targetSize && genIter.hasNext()) {60          list.add(genIter.next().value)61        }62        val offset = (0..list.size).random(it.random)63        val length = (0..(list.size - offset)).random(it.random)64        yield(build(list, offset, length))65      }66    }67  }68}69class ChunkShrinker<A> : Shrinker<Chunk<A>> {70  override fun shrink(value: Chunk<A>): List<Chunk<A>> =71    if (value.isEmpty()) emptyList()72    else listOf(73      Chunk.empty(),74      value.takeLast(1),75      value.take(value.size() / 3),76      value.take(value.size() / 2),77      value.take(value.size() * 2 / 3),78      value.dropLast(1)79    )80}81inline fun <reified A> Arb.Companion.chunk(arb: Arb<A>): Arb<Chunk<A>> =82  object : Arb<Chunk<A>>() {83    override fun edgecases(): List<Chunk<A>> =84      listOf(Chunk.empty<A>()) + arb.edgecases().map { Chunk(it) }85    override fun values(rs: RandomSource): Sequence<Sample<Chunk<A>>> =86      Arb.choose(87        5 to arb.map { Chunk.just(it) },88        10 to Arb.list(arb, 0..20).map { Chunk.iterable(it) },89        10 to Arb.set(arb, 0..20).map { Chunk.iterable(it) },90        10 to Arb.array(arb, 0..20).map { Chunk.array(it) },91        10 to Arb.boxedChunk(arb)92      ).values(rs)93  }94inline fun <reified A> Arb.Companion.boxedChunk(arb: Arb<A>): Arb<Chunk<A>> =95  object : Arb<Chunk<A>>() {96    override fun edgecases(): List<Chunk<A>> =97      listOf(Chunk.empty<A>()) + arb.edgecases().map { Chunk(it) }98    override fun values(rs: RandomSource): Sequence<Sample<Chunk<A>>> =99      arrayChunkGenerator(arb, ChunkShrinker()) { values, offset, length ->100        Chunk.boxed(values.toTypedArray(), offset, length)101      }.values(rs)102  }103fun Arb.Companion.booleanChunk(): Arb<Chunk<Boolean>> =104  object : Arb<Chunk<Boolean>>() {105    override fun edgecases(): List<Chunk<Boolean>> =106      listOf(Chunk.empty<Boolean>()) + Arb.bool().edgecases().map { Chunk(it) }107    override fun values(rs: RandomSource): Sequence<Sample<Chunk<Boolean>>> =108      Arb.choice(109        arrayChunkGenerator(Arb.bool(), ChunkShrinker()) { values, offset, length ->110          Chunk.booleans(values.toBooleanArray(), offset, length)111        },112        arrayChunkGenerator(Arb.bool(), ChunkShrinker()) { values, _, _ ->113          Chunk.array(values.toTypedArray())114        }115      ).values(rs)116  }117fun Arb.Companion.byteChunk(): Arb<Chunk<Byte>> =118  object : Arb<Chunk<Byte>>() {119    override fun edgecases(): List<Chunk<Byte>> =120      listOf(Chunk.empty<Byte>()) + Arb.byte().edgecases().map { Chunk(it) }121    override fun values(rs: RandomSource): Sequence<Sample<Chunk<Byte>>> =122      Arb.choice(123        arrayChunkGenerator(Arb.byte(), ChunkShrinker()) { values, offset, length ->124          Chunk.bytes(values.toByteArray(), offset, length)125        },126        arrayChunkGenerator(Arb.byte(), ChunkShrinker()) { values, _, _ ->127          Chunk.array(values.toTypedArray())128        }129      ).values(rs)130  }131fun Arb.Companion.intChunk(): Arb<Chunk<Int>> =132  object : Arb<Chunk<Int>>() {133    override fun edgecases(): List<Chunk<Int>> =134      listOf(Chunk.empty<Int>()) + Arb.int().edgecases().map { Chunk(it) }135    override fun values(rs: RandomSource): Sequence<Sample<Chunk<Int>>> =136      Arb.choice(137        arrayChunkGenerator(Arb.int(), ChunkShrinker()) { values, offset, length ->138          Chunk.ints(values.toIntArray(), offset, length)139        },140        arrayChunkGenerator(Arb.int(), ChunkShrinker()) { values, _, _ ->141          Chunk.array(values.toTypedArray())142        }143      ).values(rs)144  }145fun Arb.Companion.longChunk(): Arb<Chunk<Long>> =146  object : Arb<Chunk<Long>>() {147    override fun edgecases(): List<Chunk<Long>> =148      listOf(Chunk.empty<Long>()) + Arb.long().edgecases().map { Chunk(it) }149    override fun values(rs: RandomSource): Sequence<Sample<Chunk<Long>>> =150      Arb.choice(151        arrayChunkGenerator(Arb.long(), ChunkShrinker()) { values, offset, length ->152          Chunk.longs(values.toLongArray(), offset, length)153        },154        arrayChunkGenerator(Arb.long(), ChunkShrinker()) { values, _, _ ->155          Chunk.array(values.toTypedArray())156        }157      ).values(rs)158  }159fun Arb.Companion.doubleChunk(): Arb<Chunk<Double>> =160  object : Arb<Chunk<Double>>() {161    override fun edgecases(): List<Chunk<Double>> =162      listOf(Chunk.empty<Double>()) + Arb.double().edgecases().map { Chunk(it) }163    override fun values(rs: RandomSource): Sequence<Sample<Chunk<Double>>> =164      Arb.choice(165        arrayChunkGenerator(Arb.double(), ChunkShrinker()) { values, offset, length ->166          Chunk.doubles(values.toDoubleArray(), offset, length)167        },168        arrayChunkGenerator(Arb.double(), ChunkShrinker()) { values, _, _ ->169          Chunk.array(values.toTypedArray())170        }171      ).values(rs)172  }173fun Arb.Companion.floatChunk(): Arb<Chunk<Float>> =174  object : Arb<Chunk<Float>>() {175    override fun edgecases(): List<Chunk<Float>> =176      listOf(Chunk.empty<Float>()) + Arb.float().edgecases().map { Chunk(it) }177    override fun values(rs: RandomSource): Sequence<Sample<Chunk<Float>>> =178      Arb.choice(179        arrayChunkGenerator(Arb.float(), ChunkShrinker()) { values, offset, length ->180          Chunk.floats(values.toFloatArray(), offset, length)181        },182        arrayChunkGenerator(Arb.float(), ChunkShrinker()) { values, _, _ ->183          Chunk.array(values.toTypedArray())184        }185      ).values(rs)186  }187fun Arb.Companion.shortChunk(): Arb<Chunk<Short>> =188  object : Arb<Chunk<Short>>() {189    override fun edgecases(): List<Chunk<Short>> =190      listOf(Chunk.empty<Short>()) + Arb.short().edgecases().map { Chunk(it) }191    override fun values(rs: RandomSource): Sequence<Sample<Chunk<Short>>> =192      Arb.choice(193        arrayChunkGenerator(Arb.short(), ChunkShrinker()) { values, offset, length ->194          Chunk.shorts(values.toShortArray(), offset, length)195        },196        arrayChunkGenerator(Arb.short(), ChunkShrinker()) { values, _, _ ->197          Chunk.array(values.toTypedArray())198        }199      ).values(rs)200  }...

StreamSpec.kt

Source:StreamSpec.kt

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}...

ItemGens.kt

Source:ItemGens.kt

1package dev.adamko.gildedrose.testdata2import com.gildedrose.Item3import dev.adamko.config.KotestConfig.Companion.intEdgecases4import dev.adamko.config.KotestConfig.Companion.mergeAll5import io.kotest.property.Arb6import io.kotest.property.Gen7import io.kotest.property.arbitrary.alphanumeric8import io.kotest.property.arbitrary.bind9import io.kotest.property.arbitrary.filterNot10import io.kotest.property.arbitrary.map11import io.kotest.property.arbitrary.string12import io.kotest.property.arbitrary.withEdgecases13import io.kotest.property.exhaustive.exhaustive14object ItemGens {15  object Names {16    val regular = Arb.string(10, Arb.alphanumeric()).withEdgecases(17        "+5 Dexterity Vest",18        "Elixir of the Mongoose",19    )20    val aged = listOf("Aged Brie").exhaustive()21    val tickets = listOf("Backstage passes to a TAFKAL80ETC concert").exhaustive()22    val legendary = listOf("Sulfuras, Hand of Ragnaros").exhaustive()23    val conjured = listOf(regular, aged, tickets, legendary).mergeAll().map { "Conjured $it" }24    val all = listOf(regular, aged, tickets, conjured, legendary).mergeAll()25    val nonLegendary = listOf(regular, aged, tickets, conjured).mergeAll()26  }27  object SellIn {28    /**29     * Edgecases for the minimum and maximum values, as well as some that30     * are centered around the expiration date of 0.31     */32    private val edgecases: List<Int> = (-2..2) + (Int.MAX_VALUE - 1) + (Int.MIN_VALUE + 1)33    // note- ignore integer overflow for now34    val nonExpired = Arb.intEdgecases(1, Int.MAX_VALUE - 1, edgecases)35    val expired = Arb.intEdgecases(Int.MIN_VALUE + 1, 0, edgecases)36    val any = Arb.intEdgecases(Int.MIN_VALUE + 1 until Int.MAX_VALUE, edgecases)37  }38  object Quality {39    val regularValidRange = 0..5040    /** Some additional edgecases around the min/max quality range */41    private val edgecases: List<Int> =42        regularValidRange.first.let { (it - 3)..(it + 3) } +43        regularValidRange.last.let { (it - 3)..(it + 3) }44    val any = Arb.intEdgecases(Int.MIN_VALUE + 1 until Int.MAX_VALUE, edgecases)45    val validRegular = Arb.intEdgecases(regularValidRange, edgecases)46    // note- ignore integer overflow for now47    val invalidRegular = any.filterNot { it in regularValidRange }48  }49  object Binds {50    fun itemArb(51        nameGen: Gen<String> = Names.all,52        sellInGen: Gen<Int> = SellIn.any,53        qualityGen: Gen<Int> = Quality.any,54    ) = Arb.bind(nameGen, sellInGen, qualityGen) { name, sellIn, quality ->55      Item(name, sellIn, quality)56    }57  }58}...

KotestConfig.kt

Source:KotestConfig.kt

1package dev.adamko.config2import io.kotest.core.config.AbstractProjectConfig3import io.kotest.core.listeners.Listener4import io.kotest.extensions.htmlreporter.HtmlReporter5import io.kotest.extensions.junitxml.JunitXmlReporter6import io.kotest.property.Arb7import io.kotest.property.Exhaustive8import io.kotest.property.Gen9import io.kotest.property.arbitrary.IntShrinker10import io.kotest.property.arbitrary.arbitrary11import io.kotest.property.arbitrary.int12import io.kotest.property.arbitrary.merge13import kotlin.random.nextInt14class KotestConfig : AbstractProjectConfig() {15  override fun listeners(): List<Listener> = listOf(16      JunitXmlReporter(17          includeContainers = false,18          useTestPathAsName = true,19      ),20      HtmlReporter("reports/kotest")21  )22  companion object {23    inline fun <A, reified B : A> List<Gen<B>>.mergeAll(): Arb<A> =24        map { it.toArb() }25            .reduce { acc, gen -> acc.apply { merge(gen) } }26    inline fun <reified T> Gen<T>.toArb() = when (this) {27      is Arb<T>        -> this28      is Exhaustive<T> -> toArb()29    }30    fun Arb.Companion.intEdgecases(31        min: Int = Int.MIN_VALUE,32        max: Int = Int.MAX_VALUE,33        additionalEdgecases: List<Int> = emptyList(),34    ) = Arb.intEdgecases(min..max, additionalEdgecases)35    /**  Helper method to initialise a [Arb.Companion.int] with some edgecases. */36    fun Arb.Companion.intEdgecases(37        range: IntRange = Int.MIN_VALUE..Int.MAX_VALUE,38        additionalEdgecases: List<Int> = emptyList(),39    ): Arb<Int> {40      val edgecases =41          (42              listOf(-1, 0, 1, range.first, range.last, Int.MIN_VALUE, Int.MAX_VALUE) +43              additionalEdgecases44          ).filter { it in range }45      return arbitrary(edgecases, IntShrinker(range)) { it.random.nextInt(range) }46    }47  }48}...

PulsarUrnTest.kt

Source:PulsarUrnTest.kt

1package com.octaldata.session.pulsar2import com.octaldata.domain.topics.TopicName3import com.octaldata.domain.structure.DataRecordUrn4import io.kotest.core.spec.style.FunSpec5import io.kotest.matchers.shouldBe6import io.kotest.property.Arb7import io.kotest.property.arbitrary.positiveInt8import io.kotest.property.arbitrary.positiveLong9import io.kotest.property.arbitrary.string10import io.kotest.property.arbitrary.withEdgecases11import io.kotest.property.checkAll12class PulsarUrnTest : FunSpec({13   test("parse urn") {14      checkAll(15         100,16         Arb.string(1, 100),17         Arb.positiveInt().withEdgecases(-1),18         Arb.positiveLong().withEdgecases(-1),19         Arb.positiveLong().withEdgecases(-1),20      ) { topic, part, ledge, entryId ->21         parseUrn(DataRecordUrn("urn:pulsar:$topic:$part:$ledge:$entryId")).getOrThrow() shouldBe22            MessageIdentifier(TopicName(topic), part, ledge, entryId)23      }24   }25})...

MD5Test.kt

Source:MD5Test.kt

1package com.github.durun.nitron.core2import io.kotest.core.spec.style.FreeSpec3import io.kotest.matchers.shouldBe4import io.kotest.property.Arb5import io.kotest.property.arbitrary.edgecases6import io.kotest.property.arbitrary.string7class MD5Test : FreeSpec({8    "toString" {9        val testData = Arb.string().edgecases() + listOf("hogehoge")10        testData.forEach {11            val md5 = MD5.digest("hogehoge")12            println(md5.toString())13            println(md5.toStringOld())14            md5.toString() shouldBe md5.toStringOld()15        }16    }17})18private fun MD5.toStringOld(): String = String.format(19    "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",20    bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],21    bytes[8], bytes[9], bytes[10], bytes[11], bytes[12], bytes[13], bytes[14], bytes[15]22)...

RemoteDataGen.kt

Source:RemoteDataGen.kt

1package com.github.torresmi.remotedata.test.util.generation2import com.github.torresmi.remotedata.RemoteData3import io.kotest.property.Arb4import io.kotest.property.arbitrary.choice5import io.kotest.property.arbitrary.map6import io.kotest.property.arbitrary.next7fun <E : Any, A : Any> Arb.Companion.remoteData(failureGen: Arb<E>, successGen: Arb<A>) = Arb.choice(8    successGen.map { RemoteData.succeed(it) },9    failureGen.map { RemoteData.fail(it) }10).plusEdgecases(11    RemoteData.NotAsked,12    RemoteData.Loading,13    RemoteData.succeed(successGen.next()),14    RemoteData.fail(failureGen.next())15)16fun <E : Any> Arb.Companion.remoteDataNonSuccess(failureGen: Arb<E>) = failureGen.map { RemoteData.fail(it) }17    .plusEdgecases(18        RemoteData.NotAsked,19        RemoteData.Loading20    )...

Arbs.kt

Source:Arbs.kt

1package com.github.torresmi.remotedata.test.util.generation2import io.kotest.property.Arb3import io.kotest.property.arbitrary.arb4fun <A> Arb<A>.plusEdgecases(vararg edgecases: A): Arb<A> = arb(this.edgecases().plus(edgecases)) { rs ->5    generate(rs).map { it.value }6}...

Arb.edgecases

Using AI Code Generation

1    val arb = Arb.edgecases(listOf(1, 2, 3, 4, 5))2    val arb = Arb.edgecases(listOf(1, 2, 3, 4, 5))3    val arb = Arb.edgecases(listOf(1, 2, 3, 4, 5))4    val arb = Arb.edgecases(listOf(1, 2, 3, 4, 5))5    val arb = Arb.edgecases(listOf(1, 2, 3, 4, 5))6    val arb = Arb.edgecases(listOf(1, 2, 3, 4, 5))7    val arb = Arb.edgecases(listOf(1, 2, 3, 4, 5))8    val arb = Arb.edgecases(listOf(1, 2, 3, 4, 5))9    val arb = Arb.edgecases(listOf(1, 2, 3, 4, 5))10    val arb = Arb.edgecases(listOf(1, 2, 3, 4, 5))11    val arb = Arb.edgecases(listOf(1, 2, 3, 4, 5))

Arb.edgecases

Using AI Code Generation

1val arb = Arb . edgecases ( "foo" , "bar" , "baz" ) . map { it . length }2val prop = forAll ( arb ) { it == 3 }3val arb = Arb . edgecases ( "foo" , "bar" , "baz" ) . map { it . length }4val prop = forAll ( arb ) { it == 3 }5val arb = Arb . edgecases ( "foo" , "bar" , "baz" ) . map { it . length }6val prop = forAll ( arb ) { it == 3 }7val arb = Arb . edgecases ( "foo" , "bar" , "baz" ) . map { it . length }8val prop = forAll ( arb ) { it == 3 }9val arb = Arb . edgecases ( "foo" , "bar" , "baz" ) . map { it . length }10val prop = forAll ( arb ) { it == 3 }11val arb = Arb . edgecases ( "foo" , "bar" , "baz" ) . map { it . length }12val prop = forAll ( arb ) { it == 3 }13val arb = Arb . edgecases ( "foo

Arb.edgecases

Using AI Code Generation

1val arb = Arb.edgecases("a", "b", "c", "d")2val sample = arb.take(100).asSequence().toList()3val sample = arb.random()4val arb = Arb.int()5val sample = arb.take(100).asSequence().toList()6val sample = arb.random()7val arb = Arb.long()8val sample = arb.take(100).asSequence().toList()9val sample = arb.random()10val arb = Arb.double()11val sample = arb.take(100).asSequence().toList()12val sample = arb.random()13val arb = Arb.float()14val sample = arb.take(100).asSequence().toList()15val sample = arb.random()16val arb = Arb.char()17val sample = arb.take(100).asSequence().toList()18val sample = arb.random()19val arb = Arb.short()20val sample = arb.take(100).asSequence().toList()21val sample = arb.random()22val arb = Arb.byte()

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.