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

Copied to Clipboard!

How to use Exhaustive.filter method of io.kotest.property.exhaustive.Exhaustive class

Best Kotest code snippet using io.kotest.property.exhaustive.Exhaustive.Exhaustive.filter

SectionTest.kt

Source:SectionTest.kt

1/*2 * Copyright (c) 2018-2021 AnimatedLEDStrip3 *4 * Permission is hereby granted, free of charge, to any person obtaining a copy5 * of this software and associated documentation files (the "Software"), to deal6 * in the Software without restriction, including without limitation the rights7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell8 * copies of the Software, and to permit persons to whom the Software is9 * furnished to do so, subject to the following conditions:10 *11 * The above copyright notice and this permission notice shall be included in12 * all copies or substantial portions of the Software.13 *14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN20 * THE SOFTWARE.21 */22package animatedledstrip.test.leds.sectionmanagement23import animatedledstrip.communication.decodeJson24import animatedledstrip.communication.toUTF8String25import animatedledstrip.leds.emulation.createNewEmulatedStrip26import animatedledstrip.leds.sectionmanagement.LEDStripSectionManager27import animatedledstrip.leds.sectionmanagement.Section28import animatedledstrip.test.filteredStringArb29import io.kotest.assertions.throwables.shouldThrow30import io.kotest.core.spec.style.StringSpec31import io.kotest.matchers.collections.shouldHaveSize32import io.kotest.matchers.maps.shouldBeEmpty33import io.kotest.matchers.shouldBe34import io.kotest.matchers.types.shouldBeSameInstanceAs35import io.kotest.property.Arb36import io.kotest.property.Exhaustive37import io.kotest.property.arbitrary.filter38import io.kotest.property.arbitrary.int39import io.kotest.property.arbitrary.list40import io.kotest.property.arbitrary.string41import io.kotest.property.checkAll42import io.kotest.property.exhaustive.ints43class SectionTest : StringSpec(44    {45        val ledStrip = createNewEmulatedStrip(50)46        afterSpec {47            ledStrip.renderer.close()48        }49        "construction" {50            val section = Section()51            section.sections.shouldBeEmpty()52            section.subSections.shouldBeEmpty()53            section.name shouldBe ""54            section.numLEDs shouldBe 055            section.pixels.shouldHaveSize(0)56            shouldThrow<UninitializedPropertyAccessException> {57                section.stripManager58            }59        }60        "get physical index" {61            checkAll(Exhaustive.ints(0 until 49)) { s ->62                val section = LEDStripSectionManager(ledStrip).createSection("test:$s", s, 49)63                checkAll(Exhaustive.ints(0 until 49 - s)) { p ->64                    section.getPhysicalIndex(p) shouldBe p + s65                }66                checkAll(Exhaustive.ints(0 until 49 - s)) { s2 ->67                    val section2 = section.createSection("test:$s:$s2", s2, section.pixels.lastIndex)68                    checkAll(Exhaustive.ints(0 until 49 - s - s2)) { p ->69                        section2.getPhysicalIndex(p) shouldBe p + s + s270                    }71                }72                checkAll(Arb.int().filter { it !in section.pixels.indices }) { p ->73                    shouldThrow<IllegalArgumentException> {74                        section.getPhysicalIndex(p)75                    }76                }77            }78        }79        "get section" {80            val section = LEDStripSectionManager(ledStrip).fullStripSection81            section.getSection("test1") shouldBeSameInstanceAs section82            val sec = section.createSection("test1", 0, 15)83            section.getSection("test1") shouldBeSameInstanceAs sec84            section.getSection("test2") shouldBeSameInstanceAs section85        }86        "encode JSON" {87            checkAll(100, filteredStringArb, Arb.list(Arb.int(0..100000), 1..5000)) { n, p ->88                Section(n, p).jsonString() shouldBe89                        """{"type":"Section","name":"$n","pixels":${90                            p.toString().replace(" ", "")91                        },"parentSectionName":""};;;"""92            }93        }94        "decode JSON" {95            checkAll(100, filteredStringArb, Arb.list(Arb.int(0..100000), 1..5000)) { n, p ->96                val json = """{"type":"Section","name":"$n","pixels":${97                    p.toString().replace(" ", "")98                },"parentSectionName":""};;;"""99                val correctData = Section(n, p)100                val decodedData = json.decodeJson() as Section101                decodedData.name shouldBe correctData.name102                decodedData.numLEDs shouldBe correctData.numLEDs103                decodedData.pixels shouldBe correctData.pixels104            }105        }106        "encode and decode JSON" {107            checkAll(100, Arb.string(), Arb.list(Arb.int(0..100000), 1..5000)) { n, p ->108                val sec1 = Section(n, p)109                val secBytes = sec1.json()110                val sec2 = secBytes.toUTF8String().decodeJson() as Section111                sec2.name shouldBe sec1.name112                sec2.numLEDs shouldBe sec1.numLEDs113                sec2.pixels shouldBe sec1.pixels114            }115        }116    }117)...

BatchMigrationGenerator.kt

Source:BatchMigrationGenerator.kt

1package liquibase.ext.generators2import io.kotest.property.Arb3import io.kotest.property.Exhaustive4import io.kotest.property.RandomSource5import io.kotest.property.arbitrary.arbitrary6import io.kotest.property.arbitrary.filter7import io.kotest.property.arbitrary.filterNot8import io.kotest.property.arbitrary.int9import io.kotest.property.arbitrary.list10import io.kotest.property.arbitrary.long11import io.kotest.property.arbitrary.map12import io.kotest.property.arbitrary.next13import io.kotest.property.arbitrary.orNull14import io.kotest.property.exhaustive.azstring15import io.kotest.property.exhaustive.exhaustive16import io.kotest.property.exhaustive.merge17import liquibase.ext.changes.BatchMigrationChange18import java.sql.RowIdLifetime19object BatchMigrationGenerator {20    val identifierGen = { min: Int -> Exhaustive.azstring(min..16).toArb() }21    val rowIdLifeTimeInvalidGenerator = listOf(22        RowIdLifetime.ROWID_UNSUPPORTED,23        RowIdLifetime.ROWID_VALID_OTHER,24        RowIdLifetime.ROWID_VALID_SESSION,25        RowIdLifetime.ROWID_VALID_TRANSACTION26    ).exhaustive()27    val rowIdLifeTimeGenerator = listOf(28        RowIdLifetime.ROWID_VALID_FOREVER,29    ).exhaustive().merge(rowIdLifeTimeInvalidGenerator)30    val validMigrationGenerator = arbitrary { rs: RandomSource ->31        val change = BatchMigrationChange()32        val colCount = Arb.int(1, 5).next(rs)33        val colGen = fixedColumnListNoDupsGenerator(colCount, colCount)34        change.tableName = identifierGen(1).next(rs)35        change.chunkSize = Arb.long(1L, 10000L).next(rs)36        val from = colGen.next(rs)37        val fromSet = from.toSet()38        change.fromColumns = from.toColumnList()39        // Make sure we do not have overlapping or crossing columns between from and to40        val to = colGen.filterNot { l -> fromSet.any { it in l.toSet() } }.next(rs)41        change.toColumns = to.toColumnList()42        change43    }44    val validMigrationWithSleepsGenerator = arbitrary { rs: RandomSource ->45        val mig = validMigrationGenerator.next(rs)46        mig.sleepTime = Arb.long(0L, 10000L).orNull().next(rs)47        mig48    }49    val sampleMigrationGenerator = arbitrary { rs: RandomSource ->50        val change = BatchMigrationChange()51        change.tableName = identifierGen(1).orNull().next(rs)52        change.chunkSize = Arb.long(-100L, 10000L).orNull().next(rs)53        val upperBound = Arb.int(0, 5).next(rs)54        val minBound = Arb.int(0, 5).filter { it <= upperBound }.next(rs)55        change.fromColumns = fixedColumnStringSequenceGenerator(minBound, upperBound).orNull().next(rs)56        change.toColumns = fixedColumnStringSequenceGenerator(minBound, upperBound).orNull().next(rs)57        change.sleepTime = Arb.long(-100L, 10000L).orNull().next(rs)58        change59    }60    val invalidMigrationGenerator = sampleMigrationGenerator.filter { c: BatchMigrationChange ->61        val simplePredicate = c.fromColumns.isNullOrEmpty() ||62            c.toColumns.isNullOrEmpty() || (c.chunkSize ?: -1L) <= 0L || c.sleepTime?.let { it < 0L } ?: false63        if (simplePredicate) return@filter true64        else {65            val from = c.fromColumns!!.split(",")66            val to = c.toColumns!!.split(",").toSet()67            // check whether from and to columns are equal somewhere or crossing68            // check whether any to column is in primary keys69            from.size != to.size || from.any { it in to }70        }71    }72    private fun List<String>.toColumnList(): String = joinToString(separator = ",") { it }73    private val fixedColumnListGenerator = { lowerBound: Int, inclusiveUpperBound: Int ->74        Arb.list(identifierGen(1), IntRange(lowerBound, inclusiveUpperBound))75    }76    private val fixedColumnListNoDupsGenerator = { lowerBound: Int, inclusiveUpperBound: Int ->77        fixedColumnListGenerator(lowerBound, inclusiveUpperBound).filterNot { l ->78            l.toSet().size != l.size79        }80    }81    private val fixedColumnStringSequenceGenerator = { lowerBound: Int, inclusiveUpperBound: Int ->82        fixedColumnListGenerator(lowerBound, inclusiveUpperBound).map { l -> l.joinToString(",") { it } }83    }84}...

SnowflakeTest.kt

Source:SnowflakeTest.kt

1package org.tesserakt.diskordin.core.data2import io.kotest.assertions.arrow.core.shouldBeLeft3import io.kotest.assertions.arrow.core.shouldBeRight4import io.kotest.assertions.throwables.shouldThrow5import io.kotest.core.spec.style.FunSpec6import io.kotest.matchers.shouldBe7import io.kotest.matchers.string.shouldEndWith8import io.kotest.property.Arb9import io.kotest.property.Exhaustive10import io.kotest.property.arbitrary.arbitrary11import io.kotest.property.arbitrary.filter12import io.kotest.property.arbitrary.long13import io.kotest.property.checkAll14import io.kotest.property.exhaustive.azstring15import org.tesserakt.diskordin.core.data.Snowflake.ConstructionError.LessThenDiscordEpoch16import org.tesserakt.diskordin.core.data.Snowflake.ConstructionError.NotNumber17import kotlin.random.nextLong18private const val MIN_SNOWFLAKE = 4194305L19@ExperimentalUnsignedTypes20class SnowflakeTest : FunSpec() {21    private val snowflakes = arbitrary { it.random.nextLong(MIN_SNOWFLAKE..Long.MAX_VALUE) }22    init {23        test("Snowflake.toString should return number in string") {24            checkAll(snowflakes) {25                it.asSnowflake().toString() shouldBe "$it"26            }27        }28        context("Non-safe converts should throw errors comparing their rules") {29            test("String, that hasn't digits") {30                checkAll(Exhaustive.azstring(1..30)) {31                    shouldThrow<IllegalArgumentException> {32                        it.asSnowflake()33                    }.message shouldEndWith "cannot be represented as Snowflake"34                }35            }36            test("Number, that less then 0") {37                checkAll(Arb.long(max = 0).filter { it < 0 }) {38                    shouldThrow<IllegalArgumentException> {39                        it.asSnowflake()40                    }.message shouldBe "id must be greater than 0"41                }42            }43            test("Number, that less then $MIN_SNOWFLAKE") {44                checkAll(arbitrary { it.random.nextLong(MIN_SNOWFLAKE) }) {45                    shouldThrow<IllegalArgumentException> {46                        it.asSnowflake()47                    }.message shouldBe "id must be greater than ${MIN_SNOWFLAKE - 1}"48                }49            }50        }51        context("Safe converts should wrap error in data-type") {52            test("Non-digit string should produce NotANumber") {53                checkAll(Exhaustive.azstring(1..30)) {54                    val snowflake = it.asSnowflakeEither()55                    snowflake.shouldBeLeft() shouldBe NotNumber56                }57            }58            test("Numbers, that less than $MIN_SNOWFLAKE") {59                checkAll(arbitrary { it.random.nextLong(MIN_SNOWFLAKE) }) {60                    val snowflake = it.toString().asSnowflakeEither()61                    snowflake.shouldBeLeft() shouldBe LessThenDiscordEpoch62                }63            }64            test("Right snowflake should unwrap without errors") {65                checkAll(snowflakes) { it.toString().asSnowflakeEither().shouldBeRight() }66            }67        }68    }69}...

RequestGen.kt

Source:RequestGen.kt

1package com.alessandrocandolini2import io.kotest.property.Arb3import io.kotest.property.Exhaustive4import io.kotest.property.Gen5import io.kotest.property.arbitrary.bind6import io.kotest.property.arbitrary.choice7import io.kotest.property.arbitrary.filter8import io.kotest.property.arbitrary.string9import io.kotest.property.exhaustive.collection10import okhttp3.HttpUrl11import okhttp3.Request12import okhttp3.RequestBody.Companion.toRequestBody13internal object RequestGen {14    private enum class HttpMethod {15        POST, PATCH, DELETE, PUT, GET, HEAD16    }17    private val nonEmptyBodyGen: Arb<String> = Arb.string().filter { it.isNotBlank() }18    fun requestGen(pathToFullUrl: (String) -> HttpUrl): Gen<Request> {19        val httpUrlGen: Gen<HttpUrl> = Exhaustive.collection(setOf(20            "/api/v1/",21            "/api?api=test&appid=something",22            "/api?api=test"23        ).map { u -> pathToFullUrl(u) })24        return requestGen(httpUrlGen)25    }26    fun requestGen(27        httpUrlGen: Gen<HttpUrl>,28        bodyGen: Gen<String> = nonEmptyBodyGen,29        ): Gen<Request> {30        fun HttpMethod.toOkHttpMethodName() = name.toUpperCase()31        val httpMethodWithBodyGen: Gen<HttpMethod> = Exhaustive.collection(32            setOf(33                HttpMethod.POST,34                HttpMethod.PATCH,35                HttpMethod.DELETE,36                HttpMethod.PUT37            )38        )39        val httpMethodWithoutBodyGen: Gen<HttpMethod> =40            Exhaustive.collection(setOf(HttpMethod.GET, HttpMethod.HEAD))41        val requestsWithBody: Arb<Request> = Arb.bind(42            httpUrlGen,43            httpMethodWithBodyGen,44            bodyGen45        ) { httpUrl, httpMethod, body ->46            Request.Builder()47                .method(httpMethod.toOkHttpMethodName(), body.toRequestBody())48                .url(httpUrl)49                .build()50        }51        val requestsWithoutBody: Arb<Request> =52            Arb.bind(httpUrlGen, httpMethodWithoutBodyGen) { httpUrl, httpMethod ->53                Request.Builder()54                    .method(httpMethod.toOkHttpMethodName(), null)55                    .url(httpUrl)56                    .build()57            }58        return Arb.choice(59            requestsWithBody, requestsWithoutBody60        )61    }62}...

ExhaustiveUtils.kt

Source:ExhaustiveUtils.kt

1/*2 * Copyright (c) 2021 OneAndOlaf3 *4 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated5 * documentation files (the âSoftwareâ), to deal in the Software without restriction, including without limitation the6 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to7 * permit persons to whom the Software is furnished to do so, subject to the following conditions:8 *9 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the10 * Software.11 *12 * THE SOFTWARE IS PROVIDED âAS ISâ, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE13 * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR14 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR15 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.16 */17package com.github.oneandolaf.jsonext.testutils18import io.kotest.property.Exhaustive19import io.kotest.property.exhaustive.exhaustive20/**21 * Allows safe creation of an exhaustive generator for data that is mutable.22 */23fun <T> mutableExhaustive(generator: () -> Exhaustive<T>): Exhaustive<T> {24    return object : Exhaustive<T>() {25        override val values: List<T>26            get() = generator().values27    }28}29fun <A, B> Exhaustive<A>.mapMutable(f: (A) -> B): Exhaustive<B> = object : Exhaustive<B>() {30    override val values: List<B>31        get() = this@mapMutable.values.map { f(it) }32}33operator fun <A : B, B> Exhaustive<A>.minus(other: Exhaustive<B>): Exhaustive<A> {34    return (values.filter { it !in other.values }).exhaustive()35}36/**37 * Alternative to * that does not require `other`s type to be related to the type of `this`.38 */39infix fun <A, B> Exhaustive<A>.cross(other: Exhaustive<B>): Exhaustive<Pair<A, B>> {40    val values = this.values.flatMap { a ->41        other.values.map { b ->42            Pair(a, b)43        }44    }45    return values.exhaustive()46}...

Exhaustive.kt

Source:Exhaustive.kt

1package utils2import io.kotest.property.Arb3import io.kotest.property.Exhaustive4import io.kotest.property.Gen5import io.kotest.property.RandomSource6import io.kotest.property.arbitrary.byte7import io.kotest.property.arbitrary.next8import io.kotest.property.exhaustive.exhaustive9import io.kotest.property.exhaustive.filter10import io.kotest.property.exhaustive.ints11import io.kotest.property.exhaustive.map12fun <N : Number> Exhaustive<N>.toInt() = map { it.toInt() }13fun <N : Number> Exhaustive<N>.toShort() = map { it.toShort() }14fun Exhaustive.Companion.shorts(min: Short = Short.MIN_VALUE, max: Short = Short.MAX_VALUE) =15    Exhaustive.ints(min..max).map { it.toShort() }16fun Exhaustive.Companion.ubytes(min: UByte = UByte.MIN_VALUE, max: UByte = UByte.MAX_VALUE): Exhaustive<UByte> =17    Exhaustive.ints(min.toInt()..max.toInt()).map { it.toUByte() }18fun Exhaustive.Companion.ushorts(min: UShort = UShort.MIN_VALUE, max: UShort = UShort.MAX_VALUE): Exhaustive<UShort>  =19    Exhaustive.ints(min.toInt()..max.toInt()).map { it.toUShort() }20fun Exhaustive.Companion.byteArrays(length: IntRange, byte: Gen<Byte> = Arb.byte()): Exhaustive<ByteArray> {21    val generator = byte.generate(RandomSource.Default).iterator()22    return length.map { ByteArray(it) { generator.next().value } }.exhaustive()23}24operator fun <A> Exhaustive<A>.minus(other: Exhaustive<A>) =25    filter { it !in other.values }26inline fun <reified T> Exhaustive.Companion.arrayOf(value: Arb<T>, length: IntRange): Exhaustive<Array<T>> {27    return length.map { Array(it) { value.next() } }.exhaustive()28}...

PropertyBasedWithGenerators.kt

Source:PropertyBasedWithGenerators.kt

1package com.tsongkha.max2import io.kotest.assertions.withClue3import io.kotest.core.spec.style.StringSpec4import io.kotest.matchers.ints.shouldNotBeGreaterThan5import io.kotest.property.Arb6import io.kotest.property.PropertyTesting7import io.kotest.property.arbitrary.default8import io.kotest.property.arbitrary.filter9import io.kotest.property.checkAll10import io.kotest.property.exhaustive.exhaustive11import io.kotest.property.forAll12class PropertyBasedWithGenerators : StringSpec() {13    private val nonEmptyLists = Arb.default<List<Int>>().filter { it.isNotEmpty() }14    private val emptyLists = listOf(emptyList<Int>()).exhaustive()15    init {16        PropertyTesting.shouldPrintShrinkSteps = true17        PropertyTesting.shouldPrintGeneratedValues = true18        "no elements greater than myMax" {19            checkAll(nonEmptyLists) { ints ->20                val myMax = ints.myMax()!!21                ints.forEach {22                    withClue("Element of list should not be greater than myMax") {23                        it shouldNotBeGreaterThan myMax24                    }25                }26            }27        }28        "myMax is in the collection" {29            forAll(nonEmptyLists) { ints ->30                val myMax = ints.myMax()!!31                ints.contains(myMax)32            }33        }34        "empty is null" {35            forAll(emptyLists) { ints ->36                ints.myMax() == null37            }38        }39    }40}...

IntsTest.kt

Source:IntsTest.kt

1package com.sksamuel.kotest.property.exhaustive2import io.kotest.core.spec.style.FunSpec3import io.kotest.matchers.shouldBe4import io.kotest.property.Exhaustive5import io.kotest.property.exhaustive.filter6import io.kotest.property.exhaustive.flatMap7import io.kotest.property.exhaustive.ints8import io.kotest.property.exhaustive.map9class IntsTest : FunSpec({10   test("should return all filtered Ints") {11      Exhaustive.ints(0..10)12         .filter { it % 2 == 0 }13         .map { it * 2 }14         .values shouldBe listOf(0, 4, 8, 12, 16, 20)15   }16   test("flatMap works too") {17      Exhaustive.ints(0..3)18         .flatMap { Exhaustive.ints(0..it) }19         .values shouldBe listOf(0, 0, 1, 0, 1, 2, 0, 1, 2, 3)20   }21})...

Exhaustive.filter

Using AI Code Generation

1import io.kotest.property.Arb2import io.kotest.property.arbitrary.filter3import io.kotest.property.arbitrary.next4import io.kotest.property.exhaustive.Exhaustive5import io.kotest.property.exhaustive.filter6import io.kotest.property.exhaustive.next7fun main() {8val arb = Arb.exhaustive(Exhaustive.filter(Exhaustive.ints(), { it % 2 == 0 }))9println(arb.next())10}11import io.kotest.property.Arb12import io.kotest.property.arbitrary.filterNot13import io.kotest.property.arbitrary.next14import io.kotest.property.exhaustive.Exhaustive15import io.kotest.property.exhaustive.filterNot16import io.kotest.property.exhaustive.next17fun main() {18val arb = Arb.exhaustive(Exhaustive.filterNot(Exhaustive.ints(), { it % 2 == 0 }))19println(arb.next())20}21import io.kotest.property.Arb22import io.kotest.property.arbitrary.flatMap23import io.kotest.property.arbitrary.next24import io.kotest.property.exhaustive.Exhaustive25import io.kotest.property.exhaustive.flatMap26import io.kotest.property.exhaustive.next27fun main() {28val arb = Arb.exhaustive(Exhaustive.flatMap(Exhaustive.ints(), { Exhaustive.of(it.toString()) }))29println(arb.next())30}31import io.kotest.property.Arb32import io.kotest.property.arbitrary.map33import io.kotest.property.arbitrary.next34import io.kotest.property.exhaustive.Exhaustive35import io.kotest.property.exhaustive.map36import io.kotest.property.exhaustive.next37fun main() {38val arb = Arb.exhaustive(Exhaustive.map(Exhaustive.ints(), { it.toString() }))39println(arb.next())40}

Exhaustive.filter

Using AI Code Generation

1val exhaustive = Exhaustive.filter(Exhaustive.ints(), { it % 2 == 0 })2println(exhaustive.values)3val exhaustive = Exhaustive.filterNot(Exhaustive.ints(), { it % 2 == 0 })4println(exhaustive.values)5val exhaustive = Exhaustive.flatMap(Exhaustive.ints(), { Exhaustive.ints(it, it + 10) })6println(exhaustive.values)7val exhaustive = Exhaustive.map(Exhaustive.ints(), { it % 2 == 0 })8println(exhaustive.values)9val exhaustive = Exhaustive.mapNotNull(Exhaustive.ints(), { if (it % 2 == 0) it else null })10println(exhaustive.values)11val exhaustive = Exhaustive.take(Exhaustive.ints(), 5)12println(exhaustive.values)13val exhaustive = Exhaustive.takeWhile(Exhaustive.ints(), { it < 5 })14println(exhaustive.values)15val exhaustive = Exhaustive.takeUntil(Exhaustive.ints(), { it == 5 })16println(exhaustive.values)17val exhaustive = Exhaustive.zip(Exhaustive.ints(), Exhaustive.ints(), { a, b -> a + b })18println(exhaustive.values)19val exhaustive = Exhaustive.zipWithNext(Exhaustive.ints(), { a, b -> a + b })20println(exhaustive.values)

Exhaustive.filter

Using AI Code Generation

1val exhaustive = Exhaustive.filter(Exhaustive.ints(), { it % 2 == 0 })2val exhaustive = Exhaustive.filterNot(Exhaustive.ints(), { it % 2 == 0 })3val exhaustive = Exhaustive.map(Exhaustive.ints(), { it % 2 == 0 })4val exhaustive = Exhaustive.mapNotNull(Exhaustive.ints(), { if (it % 2 == 0) it else null })5val exhaustive = Exhaustive.take(Exhaustive.ints(), 5)6val exhaustive = Exhaustive.takeWhile(Exhaustive.ints(), { it < 5 })

Exhaustive.filter

Using AI Code Generation

1Exhaustive.filter ( Exhaustive . int ( 0 , 10 )) { it > 5 } . values . shouldContainExactlyInAnyOrder ( 6 , 7 , 8 , 9 , 10 )2Exhaustive . filterNot ( Exhaustive . int ( 0 , 10 )) { it > 5 } . values . shouldContainExactlyInAnyOrder ( 0 , 1 , 2 , 3 , 4 , 5 )3Exhaustive . map ( Exhaustive . int ( 0 , 10 )) { it * 2 } . values . shouldContainExactlyInAnyOrder ( 0 , 2 , 4 , 6 , 8 , 10 , 12 , 14 , 16 , 18 , 20 )4Exhaustive . flatMap ( Exhaustive . int ( 0 , 1 )) { value -> Exhaustive . int ( value * 2 , value * 2 + 1 ) } . values . shouldContainExactlyInAnyOrder ( 0 , 1 , 2 , 3 )5val  a  = Exhaustive . int ( 1 , 3 ) 6 val  b  = Exhaustive . int ( 4 , 6 ) 7 val  c  = Exhaustive . int ( 7 , 9 ) 8 Exhaustive . zip ( a ,  b ,  c ) {  i1 ,  i2 ,  i3  -> i1 + i2 + i3 } . values . shouldContainExactlyInAnyOrder ( 12 , 13 , 14 , 15 , 16 , 17 , 18 , 19 , 20 )9Exhaustive . zipWithNext ( Exhaustive . int ( 0 , 10 )) {  i1 ,  i2  -> i1 + i2

Exhaustive.filter

Using AI Code Generation

1val stringExhaustive = Exhaustive.filter(Exhaustive.strings(), { s -> s.length == 5 }) val intExhaustive = Exhaustive.filter(Exhaustive.ints(), { i -> i > 5 && i < 10 })2val stringExhaustive = Exhaustive.filterNot(Exhaustive.strings(), { s -> s.length == 5 }) val intExhaustive = Exhaustive.filterNot(Exhaustive.ints(), { i -> i > 5 && i < 10 })3val stringExhaustive = Exhaustive.map(Exhaustive.ints(), { i -> i.toString() }) val intExhaustive = Exhaustive.map(Exhaustive.strings(), { s -> s.length })4val stringExhaustive = Exhaustive.mapNotNull(Exhaustive.ints(), { i -> if (i > 5 && i < 10) i.toString() else null }) val intExhaustive = Exhaustive.mapNotNull(Exhaustive.strings(), { s -> if (s.length == 5) s.length else null })5val stringExhaustive = Exhaustive.mapIndexed(Exhaustive.ints(), { index, i -> i.toString() + index }) val intExhaustive = Exhaustive.mapIndexed(Exhaustive.strings(), { index, s -> s.length + index })6val stringExhaustive = Exhaustive.mapIndexedNotNull(Exhaustive.ints(), { index, i -> if (i > 5 && i < 10) i.toString() + index else null }) val intExhaustive = Exhaustive.mapIndexedNotNull(Exhaustive.strings(), { index, s -> if (s.length == 5) s.length + index else null })

Exhaustive.filter

Using AI Code Generation

1fun `string exhaustive filter`(exhaustive: Exhaustive<String>) = forAll(exhaustive) { s ->2}3fun `string exhaustive filter not`(exhaustive: Exhaustive<String>) = forAll(exhaustive) { s ->4}5fun `string exhaustive map`(exhaustive: Exhaustive<String>) = forAll(exhaustive) { s ->6}7fun `string exhaustive map not null`(exhaustive: Exhaustive<String>) = forAll(exhaustive) { s ->8}9fun `string exhaustive map indexed`(exhaustive: Exhaustive<String>) = forAll(exhaustive) { s ->10}11fun `string exhaustive map indexed not null`(exhaustive: Exhaustive<String>) = forAll(exhaustive) { s ->12}13fun `string exhaustive flat map`(exhaustive: Exhaustive<String>) = forAll(exhaustive) { s ->14}

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.