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

Copied to Clipboard!

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

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

TestCodeGenerators.kt

Source:TestCodeGenerators.kt

1import io.kotest.property.Arb2import io.kotest.property.Exhaustive3import io.kotest.property.arbitrary.bind4import io.kotest.property.arbitrary.list5import io.kotest.property.arbitrary.take6import io.kotest.property.exhaustive.azstring7import io.kotest.property.exhaustive.collection8import konnekt.HeadersDeclaration9import konnekt.MimeEncodingsDeclaration10import konnekt.SourcesDeclaration11import konnekt.names12import konnekt.prelude.FormUrlEncoded13import konnekt.prelude.Multipart14fun functions(source: SourcesDeclaration): List<String> {15  val annotations = annotationVariants(source)16  return when (source) {17    SourcesDeclaration.PATH -> annotations.mapIndexed { i, annotation ->18      """|@GET("/test/{p}")19         |suspend fun test${source.name}$i($annotation r: Int): String""".trimMargin()20    }21    SourcesDeclaration.BODY, SourcesDeclaration.QUERY, SourcesDeclaration.PART, SourcesDeclaration.FIELD, SourcesDeclaration.HEADER -> annotations.mapIndexed { i, annotation ->22      """|${source.optInAnnotation()}23         |@GET("/test")24         |suspend fun test${source.name}$i($annotation r: Int): String""".trimMargin()25    }26  }27}28fun headerFunctions(): Iterable<String> {29  val annotations = headerAnnotationVariants.take(50)30  return annotations.mapIndexed { i, annotation ->31    """|@GET("/test")32       |$annotation33       |suspend fun testHEADERS_$i(): String""".trimMargin()34  }.asIterable()35}36fun mimeEncodingFunctions(encoding: MimeEncodingsDeclaration): Iterable<String> {37  val annotations = encoding.names.map { "@$it" }38  return annotations.mapIndexed { i, annotation ->39    """|$annotation40       |@GET("/test")41       |suspend fun testMIME_ENCODING_$i(): String""".trimMargin()42  }43}44private fun annotationVariants(it: SourcesDeclaration): List<String> {45  return when (it) {46    SourcesDeclaration.BODY -> it.names.map { "@$it" }47    SourcesDeclaration.PATH -> (it.names product listOf("\"p\"").named("value"))48        .let { oneArg ->49          val stringOnly = oneArg.map { (name, str) -> "@$name($str)" }50          val complete = (oneArg product booleanLiterals.named("encoded")).map { (name, str, bool) -> "@$name($str, $bool)" }51          stringOnly + complete52        }53    SourcesDeclaration.QUERY, SourcesDeclaration.FIELD -> (it.names product stringLiterals.named("value"))54        .let { oneArg ->55          val stringOnly = oneArg.map { (name, str) -> "@$name($str)" }56          val complete = (oneArg product booleanLiterals.named("encoded")).map { (name, str, bool) -> "@$name($str, $bool)" }57          stringOnly + complete58        }59    SourcesDeclaration.PART, SourcesDeclaration.HEADER -> (it.names product stringLiterals.named("value"))60        .map { (name, str) -> "@$name($str)" }61  }62}63private fun SourcesDeclaration.optInAnnotation(): String {64  val name = when (this) {65    SourcesDeclaration.PART -> Multipart::class.java.simpleName66    SourcesDeclaration.FIELD -> FormUrlEncoded::class.java.simpleName67    else -> null68  }69  return name?.let { "@$it" } ?: ""70}71private val headerAnnotationVariants = Arb.bind(72    Exhaustive.collection(HeadersDeclaration.names),73    Arb.list(Exhaustive.azstring(1..10).toArb())74) { name, args ->75  val varargs = args.joinToString(", "){ "\"$it\"" }76  "@$name($varargs)"77}78private val stringLiterals = listOf(""""p"""", "\"\"")79private val booleanLiterals = listOf("true", "false")80infix fun <T, E> List<T>.product(other: List<E>): List<Pair<T, E>> {81  return flatMap { l -> other.map { r -> l to r  } }82}83@JvmName("productTriple")84infix fun <T, E, L> List<Pair<T, E>>.product(other: List<L>): List<Triple<T, E, L>> {85  return flatMap { (l1, l2) -> other.map { r -> Triple(l1, l2, r)  } }86}87private fun List<String>.named(name: String): List<Argument> = flatMap {88  listOf(Argument(it, null), Argument(it, name))89}90data class Argument(val value: String, val name: String? = null) {91  override fun toString(): String =92      if (name != null) {93        "$name = $value"94      } else {95        value96      }97}...

Exhaustive.kt

Source:Exhaustive.kt

1package io.kotest.property.exhaustive2import io.kotest.property.Arb3import io.kotest.property.Exhaustive4import kotlin.jvm.JvmName5/**6 * Returns an [Exhaustive] which provides the values from the given list.7 * @param `as` a non empty list.8 * @return [Exhaustive]9 * @throws [IllegalArgumentException] if the `as` is a empty list.10 */11fun <A> exhaustive(`as`: List<A>): Exhaustive<A> = `as`.exhaustive()12fun <A> Exhaustive.Companion.of(vararg elements: A): Exhaustive<A> = Exhaustive.collection(elements.asList())13/**14 * Returns an [Exhaustive] which provides the values from the receiver.15 * @return [Exhaustive]16 * @throws [IllegalArgumentException] if the receiver is a empty list.17 */18@JvmName("exhaustiveExt")19fun <A> List<A>.exhaustive(): Exhaustive<A> {20   require(this.isNotEmpty()) { "Can't build a Exhaustive for a empty list." }21   return object : Exhaustive<A>() {22      override val values = this@exhaustive23   }24}25/**26 * Returns a new [Exhaustive] which will merge the values from this Exhaustive and the values of27 * the supplied Exhaustive together, taking one from each in turn.28 *29 * In other words, if genA provides 1,2,3 and genB provides 7,8,9 then the merged30 * gen would output 1,7,2,8,3,9.31 *32 * The supplied gen and this gen must have a common supertype.33 *34 * @param other the arg to merge with this one35 * @return the merged arg.36 */37fun <A, B : A, C : A> Exhaustive<B>.merge(other: Exhaustive<C>): Exhaustive<A> = object : Exhaustive<A>() {38   override val values: List<A> = this@merge.values.zip(other.values).flatMap { listOf(it.first, it.second) }39}40/**41 * Returns a new [Exhaustive] which takes its elements from the receiver and filters42 * them using the supplied predicate.43 * In other words this exhaustive is a subset of the elements as determined by the filter.44 */45fun <A> Exhaustive<A>.filter(predicate: (A) -> Boolean) = object : Exhaustive<A>() {46   override val values: List<A> =47      this@filter.values.filter { predicate(it) }48}49/**50 * @return a new [Exhaustive] by filtering this Exhaustives output by the negated function [f]51 */52fun <A> Exhaustive<A>.filterNot(f: (A) -> Boolean): Exhaustive<A> = filter { !f(it) }53/**54 * Returns a new [Exhaustive] which takes its elements from the receiver and maps them using the supplied function.55 */56fun <A, B> Exhaustive<A>.map(f: (A) -> B): Exhaustive<B> = object : Exhaustive<B>() {57   override val values: List<B> =58      this@map.values.map { f(it) }59}60/**61 * Returns a new [Exhaustive] which takes its elements from the receiver and maps them using the supplied function.62 */63fun <A, B> Exhaustive<A>.flatMap(f: (A) -> Exhaustive<B>): Exhaustive<B> = object : Exhaustive<B>() {64   override val values: List<B> =65      this@flatMap.values.flatMap { f(it).values }66}67/**68 * Wraps a [Exhaustive] lazily. The given [f] is only evaluated once,69 * and not until the wrapper [Exhaustive] is evaluated.70 * */71fun <A> Exhaustive.Companion.lazy(f: () -> Exhaustive<A>): Exhaustive<A> {72   return object : Exhaustive<A>() {73      override val values: List<A> by kotlin.lazy { f().values }74   }75}...

cartesian.kt

Source:cartesian.kt

1package io.kotest.property.exhaustive2import io.kotest.property.Exhaustive3fun <A, B, C> Exhaustive<A>.cartesian(other: Exhaustive<B>, f: (A, B) -> C): Exhaustive<C> {4   val cs = values.flatMap { _a ->5      other.values.map { _b ->6         f(_a, _b)7      }8   }9   return cs.exhaustive()10}11fun <A, B> Exhaustive<A>.cartesianPairs(other: Exhaustive<B>): Exhaustive<Pair<A, B>> {12   val pairs = values.flatMap { _a ->13      other.values.map { _b ->14         Pair(_a, _b)15      }16   }17   return pairs.exhaustive()18}19/**20 * Returns the cartesian join of this exhaustive with itself, with the results as pairs.21 */22fun <A> Exhaustive<A>.cartesianPairs(): Exhaustive<Pair<A, A>> {23   val cs = values.flatMap { _a ->24      values.map { _b ->25         Pair(_a, _b)26      }27   }28   return cs.exhaustive()29}30fun <A, B, C> Exhaustive.Companion.cartesian(a: Exhaustive<A>, b: Exhaustive<B>, f: (A, B) -> C): Exhaustive<C> {31   val cs = a.values.flatMap { _a ->32      b.values.map { _b ->33         f(_a, _b)34      }35   }36   return cs.exhaustive()37}38fun <A, B> Exhaustive.Companion.cartesianPairs(a: Exhaustive<A>, b: Exhaustive<B>): Exhaustive<Pair<A, B>> {39   val pairs = a.values.flatMap { _a ->40      b.values.map { _b ->41         Pair(_a, _b)42      }43   }44   return pairs.exhaustive()45}46fun <A, B, C, D> Exhaustive.Companion.cartesian(47   a: Exhaustive<A>,48   b: Exhaustive<B>,49   c: Exhaustive<C>,50   f: (A, B, C) -> D51): Exhaustive<D> {52   val ds = a.values.flatMap { _a ->53      b.values.flatMap { _b ->54         c.values.map { _c ->55            f(_a, _b, _c)56         }57      }58   }59   return ds.exhaustive()60}61fun <A, B, C, D, E> Exhaustive.Companion.cartesian(62   a: Exhaustive<A>,63   b: Exhaustive<B>,64   c: Exhaustive<C>,65   d: Exhaustive<D>,66   f: (A, B, C, D) -> E67): Exhaustive<E> {68   val es = a.values.flatMap { _a ->69      b.values.flatMap { _b ->70         c.values.flatMap { _c ->71            d.values.map { _d ->72               f(_a, _b, _c, _d)73            }74         }75      }76   }77   return es.exhaustive()78}79fun <A, B, C, D, E, F> Exhaustive.Companion.cartesian(80   a: Exhaustive<A>,81   b: Exhaustive<B>,82   c: Exhaustive<C>,83   d: Exhaustive<D>,84   e: Exhaustive<E>,85   f: (A, B, C, D, E) -> F86): Exhaustive<F> {87   val fs = a.values.flatMap { _a ->88      b.values.flatMap { _b ->89         c.values.flatMap { _c ->90            d.values.flatMap { _d ->91               e.values.map { _e ->92                  f(_a, _b, _c, _d, _e)93               }94            }95         }96      }97   }98   return fs.exhaustive()99}...

NumericTest.kt

Source:NumericTest.kt

1package org.tesserakt.diskordin.util.typeclass2import io.kotest.core.spec.style.StringSpec3import io.kotest.core.spec.style.stringSpec4import io.kotest.data.forAll5import io.kotest.data.row6import io.kotest.matchers.shouldBe7import io.kotest.property.Arb8import io.kotest.property.arbitrary.*9import io.kotest.property.checkAll10import io.kotest.property.exhaustive.exhaustive11import org.tesserakt.diskordin.impl.util.typeclass.BigDecimalK12import org.tesserakt.diskordin.impl.util.typeclass.numeric13class NumericTest : StringSpec({14    include("Int ", Int.numeric().test())15    include("Long ", Long.numeric().test())16    include("Double ", Double.numeric().test())17    include("Float ", Float.numeric().test())18    include("Byte ", Byte.numeric().test())19    include("Short ", Short.numeric().test())20    include("BigDecimal ", BigDecimalK.numeric().test())21})22private fun <N : Number> Numeric<N>.test() = stringSpec {23    "Converting" {24        zero.toInt() shouldBe 025        zero.toFloat() shouldBe 0f26        zero.toLong() shouldBe 0L27        zero.toDouble() shouldBe 0.028    }29    "Addition" {30        forAll(31            row(1.fromInt(), 2.fromInt(), 3.fromInt()),32            row((-1).fromInt(), (-7).fromInt(), (-8).fromInt()),33            row(zero, zero, zero),34            row((-2).fromInt(), 5.fromInt(), 3.fromInt())35        ) { a, b, sum ->36            a + b shouldBe sum37        }38    }39    "Subtraction" {40        forAll(41            row(1.fromInt(), 2.fromInt(), (-1).fromInt()),42            row((-1).fromInt(), (-7).fromInt(), 6.fromInt()),43            row(zero, zero, zero),44            row((-2).fromInt(), 5.fromInt(), (-7).fromInt())45        ) { a, b, diff ->46            a - b shouldBe diff47        }48    }49    "Multiplication" {50        forAll(51            row(1.fromInt(), 2.fromInt(), 2.fromInt()),52            row((-1).fromInt(), (-7).fromInt(), 7.fromInt()),53            row(zero, zero, zero),54            row((-2).fromInt(), 5.fromInt(), (-10).fromInt())55        ) { a, b, product ->56            a * b shouldBe product57        }58    }59    "Absolute" {60        val numbers = Arb.bind(Arb.long(), Arb.int(), Arb.double(), Arb.float()) { long, int, double, float ->61            listOf(long.fromLong(), double.fromDouble(), int.fromInt(), float.fromFloat()).exhaustive()62        }.flatMap { it.toArb() }63        checkAll(numbers) { a: N ->64            (a.abs() >= zero) shouldBe true65        }66    }67}...

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

basics.kt

Source:basics.kt

1package io.kotest.property.exhaustive2import io.kotest.property.Exhaustive3/**4 * Returns a [Exhaustive] of the two possible boolean values - true and false.5 */6fun Exhaustive.Companion.boolean(): Exhaustive<Boolean> = listOf(true, false).exhaustive()7/**8 * Returns a [Exhaustive] whose value is a single constant.9 */10fun <A> Exhaustive.Companion.constant(a: A): Exhaustive<A> = listOf(a).exhaustive()11fun Exhaustive.Companion.nullable(): Exhaustive<Nothing?> = listOf(null).exhaustive()12fun <A> Exhaustive<A>.andNull(): Exhaustive<A?> = (this.values + listOf(null)).exhaustive()13/**14 * Returns an Exhaustive which is the concatentation of this exhaustive values plus15 * the given exhaustive's values.16 */17operator fun <A> Exhaustive<A>.plus(other: Exhaustive<A>) = (this.values + other.values).exhaustive()18/**19 * Returns an Exhaustive which is the concatentation of this exhaustive values plus20 * the given exhaustive's values.21 *22 * Alias for [plus].23 */24fun <A> Exhaustive<A>.concat(other: Exhaustive<A>) = this + other25/**26 * Returns the cross product of two [Exhaustive]s.27 */28operator fun <A, B : A> Exhaustive<A>.times(other: Exhaustive<B>): Exhaustive<Pair<A, B>> {29   val values = this.values.flatMap { a ->30      other.values.map { b ->31         Pair(a, b)32      }33   }34   return values.exhaustive()35}...

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

strings.kt

Source:strings.kt

1package io.kotest.property.exhaustive2import io.kotest.property.Exhaustive3fun Exhaustive.Companion.azstring(range: IntRange): Exhaustive<String> {4   fun az() = ('a'..'z').map { it.toString() }5   val values = range.toList().flatMap { size ->6      List(size) { az() }.reduce { acc, seq -> acc.zip(seq).map { (a, b) -> a + b } }7   }8   return values.exhaustive()9}...

Exhaustive.flatMap

Using AI Code Generation

1val intExhaustive = Exhaustive.ints(0..10)2val stringExhaustive = Exhaustive.strings(5)3val intStringExhaustive = intExhaustive.flatMap { i -> stringExhaustive.map { s -> i to s } }4val intStringExhaustive = intExhaustive.flatMap { i -> stringExhaustive.map { s -> i to s } }5val intExhaustive = Exhaustive.ints(0..10)6val stringExhaustive = Exhaustive.strings(5)7val intStringExhaustive = intExhaustive.flatMap { i -> stringExhaustive.map { s -> i to s } }8val intStringExhaustive = intExhaustive.flatMap { i -> stringExhaustive.map { s -> i to s } }9val intExhaustive = Exhaustive.ints(0..10)10val stringExhaustive = Exhaustive.strings(5)11val intStringExhaustive = intExhaustive.flatMap { i -> stringExhaustive.map { s -> i to s } }12val intStringExhaustive = intExhaustive.flatMap { i -> stringExhaustive.map { s -> i to s } }13val intExhaustive = Exhaustive.ints(0..10)14val stringExhaustive = Exhaustive.strings(5)15val intStringExhaustive = intExhaustive.flatMap { i -> stringExhaustive.map { s -> i to s } }16val intStringExhaustive = intExhaustive.flatMap { i -> stringExhaustive.map { s -> i to s } }17val intExhaustive = Exhaustive.ints(0..10)18val stringExhaustive = Exhaustive.strings(5)19val intStringExhaustive = intExhaustive.flatMap { i -> stringExhaustive.map { s -> i to s } }20val intStringExhaustive = intExhaustive.flatMap { i -> stringExhaustive.map { s ->

Exhaustive.flatMap

Using AI Code Generation

1val list1 = listOf(1, 2, 3)2val list2 = listOf("a", "b", "c")3Exhaustive.flatMap(list1, list2) { a, b -> a to b }4[(1, a), (1, b), (1, c), (2, a), (2, b), (2, c), (3, a), (3, b), (3, c)]5val list1 = listOf(1, 2, 3)6val list2 = listOf("a", "b", "c")7Exhaustive.cartesianProduct(list1, list2) { a, b -> a to b }8[(1, a), (1, b), (1, c), (2, a), (2, b), (2, c), (3, a), (3, b), (3, c)]9val list1 = listOf(1, 2, 3)10val list2 = listOf("a", "b", "c")11Exhaustive.zip(list1, list2) { a, b -> a to b }12[(1, a), (2, b), (3, c)]13val list1 = listOf(1, 2, 3)14val list2 = listOf("a", "b", "c")15Exhaustive.map(list1, list2) { a, b -> a to b }16[(1, a), (2, b), (3, c)]17val list1 = listOf(1, 2, 3)18val list2 = listOf("

Exhaustive.flatMap

Using AI Code Generation

1val  result  =  Exhaustive .flatMap ( Exhaustive .ints ( 0 ,  10 ),  Exhaustive .ints ( 0 ,  10 )) {  a ,  b  ->  a  +  b  }2val  result  =  Exhaustive .map ( Exhaustive .ints ( 0 ,  10 )) {  a  ->  a  +  1  }3val  result  =  Exhaustive .mapNotNull ( Exhaustive .ints ( 0 ,  10 )) {  a  ->  if  ( a  >  5 )  a  else   null  }4val  result  =  Exhaustive .mapNotNull ( Exhaustive .ints ( 0 ,  10 )) {  a  ->  if  ( a  >  5 )  a  else   null  }5val  result  =  Exhaustive .shrink ( Exhaustive .ints ( 0 ,  10 ),  5 )6val  result  =  Exhaustive .shrink ( Exhaustive .ints ( 0 ,  10 ),  5 )7val  result  =  Exhaustive .shrink ( Exhaustive .ints ( 0 ,  10 ),  5 )8val  result  =  Exhaustive .shrink ( Exhaustive .ints ( 0 ,  10 ),  5 )9val  result  =  Exhaustive .shrink ( Exhaustive .ints (

Exhaustive.flatMap

Using AI Code Generation

1val  exhaustive  =  Exhaustive . of ( 1 , 2 , 3 , 4 , 5 ) 2 val  result  =  exhaustive . flatMap {  n  ->  Exhaustive . of ( n , n  *  2 ) } 3val  exhaustive  =  Exhaustive . of ( 1 , 2 , 3 , 4 , 5 ) 4 val  result  =  exhaustive . map {  n  ->  n  *  2 } 5val  exhaustive  =  Exhaustive . of ( 1 , 2 , 3 , 4 , 5 ) 6 val  result  =  exhaustive . filter {  n  ->  n  %  2  ==  0 } 7val  exhaustive  =  Exhaustive . of ( 1 , 2 , 3 , 4 , 5 ) 8 val  result  =  exhaustive . filterNot {  n  ->  n  %  2  ==  0 } 9val  exhaustive  =  Exhaustive . of ( 1 , 2 , 3 , 4 , 5 ) 10 val  result  =  exhaustive . take ( 3 ) 11val  exhaustive  =  Exhaustive . of ( 1 , 2 , 3 , 4 , 5 )

Exhaustive.flatMap

Using AI Code Generation

1val exhaustive = Exhaustive . of ( "A" , "B" , "C" ) val result = exhaustive . flatMap { Exhaustive . of ( it , it . repeat ( 2 ) ) } result . values . toList () shouldBe listOf ( "A" , "AA" , "B" , "BB" , "C" , "CC" )2val exhaustive = Exhaustive . of ( "A" , "B" , "C" ) val result = exhaustive . filter { it == "A" } result . values . toList () shouldBe listOf ( "A" )3val exhaustive = Exhaustive . of ( "A" , "B" , "C" ) val result = exhaustive . filterNot { it == "A" } result . values . toList () shouldBe listOf ( "B" , "C" )4val exhaustive = Exhaustive . of ( "A" , "B" , "C" ) val result = exhaustive . mapNotNull { if ( it == "A" ) null else it } result . values . toList () shouldBe listOf ( "B" , "C" )5val exhaustive = Exhaustive . of ( "A" , "B" , "C" ) val result = exhaustive . map { it + it } result . values . toList () shouldBe listOf ( "AA" , "BB" , "CC" )6val exhaustive = Exhaustive . of ( "A" , "B" , "C" ) val result = exhaustive . take ( 2 ) result . values . toList () shouldBe listOf ( "A" , "B" )7val exhaustive = Exhaustive . of ( "A" , "B" , "C" ) val result = exhaustive . takeLast

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.