How to use PropertyContext class of io.kotest.property package

...16@file:Suppress("TooManyFunctions")17package com.appmattus.kotlinfixture.kotest18import com.appmattus.kotlinfixture.Fixture19import io.kotest.property.PropTestConfig20import io.kotest.property.PropertyContext21import io.kotest.property.checkAll22// 1 parameter23/**24 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.25 */26suspend inline fun <reified A> Fixture.checkAll(27    noinline function: suspend PropertyContext.(a: A) -> Unit28) = checkAll(kotestGen(), function)29/**30 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.31 */32suspend inline fun <reified A> Fixture.checkAll(33    iterations: Int,34    noinline function: suspend PropertyContext.(a: A) -> Unit35) = checkAll(iterations, kotestGen(), function)36/**37 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.38 */39suspend inline fun <reified A> Fixture.checkAll(40    config: PropTestConfig,41    noinline function: suspend PropertyContext.(a: A) -> Unit42) = checkAll(config, kotestGen(), function)43/**44 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.45 */46suspend inline fun <reified A> Fixture.checkAll(47    iterations: Int,48    config: PropTestConfig,49    noinline function: suspend PropertyContext.(a: A) -> Unit50) = checkAll(iterations, config, kotestGen(), function)51// 2 parameters52/**53 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.54 */55suspend inline fun <reified A, reified B> Fixture.checkAll(56    noinline function: suspend PropertyContext.(a: A, b: B) -> Unit57) = checkAll(kotestGen(), kotestGen(), function)58/**59 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.60 */61suspend inline fun <reified A, reified B> Fixture.checkAll(62    iterations: Int,63    noinline function: suspend PropertyContext.(a: A, b: B) -> Unit64) = checkAll(iterations, kotestGen(), kotestGen(), function)65/**66 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.67 */68suspend inline fun <reified A, reified B> Fixture.checkAll(69    config: PropTestConfig,70    noinline function: suspend PropertyContext.(a: A, b: B) -> Unit71) = checkAll(config, kotestGen(), kotestGen(), function)72/**73 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.74 */75suspend inline fun <reified A, reified B> Fixture.checkAll(76    iterations: Int,77    config: PropTestConfig,78    noinline function: suspend PropertyContext.(a: A, b: B) -> Unit79) = checkAll(iterations, config, kotestGen(), kotestGen(), function)80// 3 parameters81/**82 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.83 */84suspend inline fun <reified A, reified B, reified C> Fixture.checkAll(85    noinline function: suspend PropertyContext.(a: A, b: B, c: C) -> Unit86) = checkAll(kotestGen(), kotestGen(), kotestGen(), function)87/**88 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.89 */90suspend inline fun <reified A, reified B, reified C> Fixture.checkAll(91    iterations: Int,92    noinline function: suspend PropertyContext.(a: A, b: B, c: C) -> Unit93) = checkAll(iterations, kotestGen(), kotestGen(), kotestGen(), function)94/**95 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.96 */97suspend inline fun <reified A, reified B, reified C> Fixture.checkAll(98    config: PropTestConfig,99    noinline function: suspend PropertyContext.(a: A, b: B, c: C) -> Unit100) = checkAll(config, kotestGen(), kotestGen(), kotestGen(), function)101/**102 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.103 */104suspend inline fun <reified A, reified B, reified C> Fixture.checkAll(105    iterations: Int,106    config: PropTestConfig,107    noinline function: suspend PropertyContext.(a: A, b: B, c: C) -> Unit108) = checkAll(iterations, config, kotestGen(), kotestGen(), kotestGen(), function)109// 4 parameters110/**111 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.112 */113suspend inline fun <reified A, reified B, reified C, reified D> Fixture.checkAll(114    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D) -> Unit115) = checkAll(kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)116/**117 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.118 */119suspend inline fun <reified A, reified B, reified C, reified D> Fixture.checkAll(120    iterations: Int,121    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D) -> Unit122) = checkAll(iterations, kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)123/**124 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.125 */126suspend inline fun <reified A, reified B, reified C, reified D> Fixture.checkAll(127    config: PropTestConfig,128    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D) -> Unit129) = checkAll(config, kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)130/**131 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.132 */133suspend inline fun <reified A, reified B, reified C, reified D> Fixture.checkAll(134    iterations: Int,135    config: PropTestConfig,136    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D) -> Unit137) = checkAll(iterations, config, kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)138// 5 parameters139/**140 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.141 */142suspend inline fun <reified A, reified B, reified C, reified D, reified E> Fixture.checkAll(143    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E) -> Unit144) = checkAll(kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)145/**146 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.147 */148suspend inline fun <reified A, reified B, reified C, reified D, reified E> Fixture.checkAll(149    iterations: Int,150    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E) -> Unit151) = checkAll(iterations, kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)152/**153 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.154 */155suspend inline fun <reified A, reified B, reified C, reified D, reified E> Fixture.checkAll(156    config: PropTestConfig,157    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E) -> Unit158) = checkAll(config, kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)159/**160 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.161 */162suspend inline fun <reified A, reified B, reified C, reified D, reified E> Fixture.checkAll(163    iterations: Int,164    config: PropTestConfig,165    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E) -> Unit166) = checkAll(iterations, config, kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)167// 6 parameters168/**169 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.170 */171suspend inline fun <reified A, reified B, reified C, reified D, reified E, reified F> Fixture.checkAll(172    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E, f: F) -> Unit173) = checkAll(kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)174/**175 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.176 */177suspend inline fun <reified A, reified B, reified C, reified D, reified E, reified F> Fixture.checkAll(178    iterations: Int,179    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E, f: F) -> Unit180) = checkAll(iterations, kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)181/**182 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.183 */184suspend inline fun <reified A, reified B, reified C, reified D, reified E, reified F> Fixture.checkAll(185    config: PropTestConfig,186    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E, f: F) -> Unit187) = checkAll(config, kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)188/**189 * Use [Fixture] to generate random objects for type parameters and validate the [function] has no assertion failures.190 */191suspend inline fun <reified A, reified B, reified C, reified D, reified E, reified F> Fixture.checkAll(192    iterations: Int,193    config: PropTestConfig,194    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E, f: F) -> Unit195) = checkAll(iterations, config, kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)...

...16@file:Suppress("TooManyFunctions")17package com.appmattus.kotlinfixture.kotest18import com.appmattus.kotlinfixture.Fixture19import io.kotest.property.PropTestConfig20import io.kotest.property.PropertyContext21import io.kotest.property.forAll22// 1 parameter23/**24 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.25 */26suspend inline fun <reified A> Fixture.forAll(27    noinline function: suspend PropertyContext.(a: A) -> Boolean28) = forAll(kotestGen(), function)29/**30 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.31 */32suspend inline fun <reified A> Fixture.forAll(33    iterations: Int,34    noinline function: suspend PropertyContext.(a: A) -> Boolean35) = forAll(iterations, kotestGen(), function)36/**37 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.38 */39suspend inline fun <reified A> Fixture.forAll(40    config: PropTestConfig,41    noinline function: suspend PropertyContext.(a: A) -> Boolean42) = forAll(config, kotestGen(), function)43/**44 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.45 */46suspend inline fun <reified A> Fixture.forAll(47    iterations: Int,48    config: PropTestConfig,49    noinline function: suspend PropertyContext.(a: A) -> Boolean50) = forAll(iterations, config, kotestGen(), function)51// 2 parameters52/**53 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.54 */55suspend inline fun <reified A, reified B> Fixture.forAll(56    noinline function: suspend PropertyContext.(a: A, b: B) -> Boolean57) = forAll(kotestGen(), kotestGen(), function)58/**59 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.60 */61suspend inline fun <reified A, reified B> Fixture.forAll(62    iterations: Int,63    noinline function: suspend PropertyContext.(a: A, b: B) -> Boolean64) = forAll(iterations, kotestGen(), kotestGen(), function)65/**66 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.67 */68suspend inline fun <reified A, reified B> Fixture.forAll(69    config: PropTestConfig,70    noinline function: suspend PropertyContext.(a: A, b: B) -> Boolean71) = forAll(config, kotestGen(), kotestGen(), function)72/**73 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.74 */75suspend inline fun <reified A, reified B> Fixture.forAll(76    iterations: Int,77    config: PropTestConfig,78    noinline function: suspend PropertyContext.(a: A, b: B) -> Boolean79) = forAll(iterations, config, kotestGen(), kotestGen(), function)80// 3 parameters81/**82 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.83 */84suspend inline fun <reified A, reified B, reified C> Fixture.forAll(85    noinline function: suspend PropertyContext.(a: A, b: B, c: C) -> Boolean86) = forAll(kotestGen(), kotestGen(), kotestGen(), function)87/**88 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.89 */90suspend inline fun <reified A, reified B, reified C> Fixture.forAll(91    iterations: Int,92    noinline function: suspend PropertyContext.(a: A, b: B, c: C) -> Boolean93) = forAll(iterations, kotestGen(), kotestGen(), kotestGen(), function)94/**95 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.96 */97suspend inline fun <reified A, reified B, reified C> Fixture.forAll(98    config: PropTestConfig,99    noinline function: suspend PropertyContext.(a: A, b: B, c: C) -> Boolean100) = forAll(config, kotestGen(), kotestGen(), kotestGen(), function)101/**102 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.103 */104suspend inline fun <reified A, reified B, reified C> Fixture.forAll(105    iterations: Int,106    config: PropTestConfig,107    noinline function: suspend PropertyContext.(a: A, b: B, c: C) -> Boolean108) = forAll(iterations, config, kotestGen(), kotestGen(), kotestGen(), function)109// 4 parameters110/**111 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.112 */113suspend inline fun <reified A, reified B, reified C, reified D> Fixture.forAll(114    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D) -> Boolean115) = forAll(kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)116/**117 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.118 */119suspend inline fun <reified A, reified B, reified C, reified D> Fixture.forAll(120    iterations: Int,121    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D) -> Boolean122) = forAll(iterations, kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)123/**124 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.125 */126suspend inline fun <reified A, reified B, reified C, reified D> Fixture.forAll(127    config: PropTestConfig,128    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D) -> Boolean129) = forAll(config, kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)130/**131 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.132 */133suspend inline fun <reified A, reified B, reified C, reified D> Fixture.forAll(134    iterations: Int,135    config: PropTestConfig,136    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D) -> Boolean137) = forAll(iterations, config, kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)138// 5 parameters139/**140 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.141 */142suspend inline fun <reified A, reified B, reified C, reified D, reified E> Fixture.forAll(143    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E) -> Boolean144) = forAll(kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)145/**146 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.147 */148suspend inline fun <reified A, reified B, reified C, reified D, reified E> Fixture.forAll(149    iterations: Int,150    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E) -> Boolean151) = forAll(iterations, kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)152/**153 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.154 */155suspend inline fun <reified A, reified B, reified C, reified D, reified E> Fixture.forAll(156    config: PropTestConfig,157    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E) -> Boolean158) = forAll(config, kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)159/**160 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.161 */162suspend inline fun <reified A, reified B, reified C, reified D, reified E> Fixture.forAll(163    iterations: Int,164    config: PropTestConfig,165    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E) -> Boolean166) = forAll(iterations, config, kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)167// 6 parameters168/**169 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.170 */171suspend inline fun <reified A, reified B, reified C, reified D, reified E, reified F> Fixture.forAll(172    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E, f: F) -> Boolean173) = forAll(kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)174/**175 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.176 */177suspend inline fun <reified A, reified B, reified C, reified D, reified E, reified F> Fixture.forAll(178    iterations: Int,179    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E, f: F) -> Boolean180) = forAll(iterations, kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)181/**182 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.183 */184suspend inline fun <reified A, reified B, reified C, reified D, reified E, reified F> Fixture.forAll(185    config: PropTestConfig,186    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E, f: F) -> Boolean187) = forAll(config, kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)188/**189 * Use [Fixture] to generate random objects for type parameters and validate the [function] returns true `forAll`.190 */191suspend inline fun <reified A, reified B, reified C, reified D, reified E, reified F> Fixture.forAll(192    iterations: Int,193    config: PropTestConfig,194    noinline function: suspend PropertyContext.(a: A, b: B, c: C, d: D, e: E, f: F) -> Boolean195) = forAll(iterations, config, kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), kotestGen(), function)...

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

2import arrow.core.Tuple23import arrow.core.Tuple34import io.kotest.core.spec.style.FreeSpec5import io.kotest.property.Arb6import io.kotest.property.PropertyContext7import io.kotest.property.arbitrary.bind8import io.kotest.property.checkAll9/**10 * Simple overwritten Kotest FreeSpec to reduce stress on tests.11 */12abstract class ArrowFxSpec(13  private val iterations: Int = 350,14  spec: ArrowFxSpec.() -> Unit = {}15) : FreeSpec() {16  init {17    spec()18  }19  suspend fun checkAll(property: suspend PropertyContext.() -> Unit): PropertyContext =20    checkAll(iterations, Arb.unit()) { property() }21  suspend fun <A> checkAll(22    genA: Arb<A>,23    property: suspend PropertyContext.(A) -> Unit24  ): PropertyContext =25    checkAll(26      iterations,27      genA,28      property29    )30  suspend fun <A, B> checkAll(31    genA: Arb<A>,32    genB: Arb<B>,33    property: suspend PropertyContext.(A, B) -> Unit34  ): PropertyContext =35    checkAll(36      iterations,37      genA,38      genB,39      property40    )41  suspend fun <A, B, C> checkAll(42    genA: Arb<A>,43    genB: Arb<B>,44    genC: Arb<C>,45    property: suspend PropertyContext.(A, B, C) -> Unit46  ): PropertyContext =47    checkAll(48      iterations,49      genA,50      genB,51      genC,52      property53    )54  suspend fun <A, B, C, D> checkAll(55    genA: Arb<A>,56    genB: Arb<B>,57    genC: Arb<C>,58    genD: Arb<D>,59    property: suspend PropertyContext.(A, B, C, D) -> Unit60  ): PropertyContext =61    checkAll(62      iterations,63      genA,64      genB,65      genC,66      genD,67      property68    )69  suspend fun <A, B, C, D, E> checkAll(70    genA: Arb<A>,71    genB: Arb<B>,72    genC: Arb<C>,73    genD: Arb<D>,74    genE: Arb<E>,75    property: suspend PropertyContext.(A, B, C, D, E) -> Unit76  ): PropertyContext =77    checkAll(78      iterations,79      genA,80      genB,81      genC,82      genD,83      genE,84      property85    )86  suspend fun <A, B, C, D, E, F> checkAll(87    genA: Arb<A>,88    genB: Arb<B>,89    genC: Arb<C>,90    genD: Arb<D>,91    genE: Arb<E>,92    genF: Arb<F>,93    property: suspend PropertyContext.(A, B, C, D, E, F) -> Unit94  ): PropertyContext =95    checkAll(96      iterations,97      genA,98      genB,99      genC,100      genD,101      genE,102      genF,103      property104    )105  suspend fun <A, B, C, D, E, F, G> checkAll(106    genA: Arb<A>,107    genB: Arb<B>,108    genC: Arb<C>,109    genD: Arb<D>,110    genE: Arb<E>,111    genF: Arb<F>,112    genG: Arb<G>,113    property: suspend PropertyContext.(A, B, C, D, E, F, G) -> Unit114  ): PropertyContext =115    checkAll(116      iterations,117      genA,118      genB,119      genC,120      genD,121      genE,122      Arb.bind(genF, genG, ::Tuple2)123    ) { a, b, c, d, e, (f, g) ->124      property(a, b, c, d, e, f, g)125    }126  suspend fun <A, B, C, D, E, F, G, H> checkAll(127    genA: Arb<A>,128    genB: Arb<B>,129    genC: Arb<C>,130    genD: Arb<D>,131    genE: Arb<E>,132    genF: Arb<F>,133    genG: Arb<G>,134    genH: Arb<H>,135    property: suspend PropertyContext.(A, B, C, D, E, F, G, H) -> Unit136  ): PropertyContext =137    checkAll(138      iterations,139      genA,140      genB,141      genC,142      genD,143      genE,144      Arb.bind(genF, genG, genH, ::Tuple3)145    ) { a, b, c, d, e, (f, g, h) ->146      property(a, b, c, d, e, f, g, h)147    }148  suspend fun forFew(149    iterations: Int,150    property: suspend PropertyContext.(Unit) -> Unit151  ): PropertyContext =152    checkAll(153      iterations,154      Arb.unit(),155      property156    )157}...

...3import arrow.core.compose4import arrow.core.identity5import arrow.optics.Prism6import io.kotest.property.Arb7import io.kotest.property.PropertyContext8import io.kotest.property.arrow.laws.Law9import io.kotest.property.arrow.laws.equalUnderTheLaw10import io.kotest.property.checkAll11public object PrismLaws {12  public fun <A, B> laws(13    prism: Prism<A, B>,14    aGen: Arb<A>,15    bGen: Arb<B>,16    funcGen: Arb<(B) -> B>,17    eqa: (A, A) -> Boolean = { a, b -> a == b },18    eqb: (B?, B?) -> Boolean = { a, b -> a == b }19  ): List<Law> = listOf(20    Law("Prism law: partial round trip one way") { prism.partialRoundTripOneWay(aGen, eqa) },21    Law("Prism law: round trip other way") { prism.roundTripOtherWay(bGen, eqb) },22    Law("Prism law: modify identity") { prism.modifyIdentity(aGen, eqa) },23    Law("Prism law: compose modify") { prism.composeModify(aGen, funcGen, eqa) },24    Law("Prism law: consistent set modify") { prism.consistentSetModify(aGen, bGen, eqa) }25  )26  public suspend fun <A, B> Prism<A, B>.partialRoundTripOneWay(aGen: Arb<A>, eq: (A, A) -> Boolean): PropertyContext =27    checkAll(aGen) { a ->28      getOrModify(a).fold(::identity, ::reverseGet)29        .equalUnderTheLaw(a, eq)30    }31  public suspend fun <A, B> Prism<A, B>.roundTripOtherWay(bGen: Arb<B>, eq: (B?, B?) -> Boolean): PropertyContext =32    checkAll(bGen) { b ->33      getOrNull(reverseGet(b))34        .equalUnderTheLaw(b, eq)35    }36  public suspend fun <A, B> Prism<A, B>.modifyIdentity(aGen: Arb<A>, eq: (A, A) -> Boolean): PropertyContext =37    checkAll(aGen) { a ->38      modify(a, ::identity).equalUnderTheLaw(a, eq)39    }40  public suspend fun <A, B> Prism<A, B>.composeModify(aGen: Arb<A>, funcGen: Arb<(B) -> B>, eq: (A, A) -> Boolean): PropertyContext =41    checkAll(aGen, funcGen, funcGen) { a, f, g ->42      modify(modify(a, f), g).equalUnderTheLaw(modify(a, g compose f), eq)43    }44  public suspend fun <A, B> Prism<A, B>.consistentSetModify(aGen: Arb<A>, bGen: Arb<B>, eq: (A, A) -> Boolean): PropertyContext =45    checkAll(aGen, bGen) { a, b ->46      set(a, b).equalUnderTheLaw(modify(a) { b }, eq)47    }48}

...3import arrow.core.compose4import arrow.core.identity5import arrow.optics.Iso6import io.kotest.property.Arb7import io.kotest.property.PropertyContext8import io.kotest.property.arrow.laws.Law9import io.kotest.property.arrow.laws.equalUnderTheLaw10import io.kotest.property.checkAll11public object IsoLaws {12  public fun <A, B> laws(13    iso: Iso<A, B>,14    aGen: Arb<A>,15    bGen: Arb<B>,16    funcGen: Arb<(B) -> B>,17    eqa: (A, A) -> Boolean = { a, b -> a == b },18    eqb: (B, B) -> Boolean = { a, b -> a == b }19  ): List<Law> =20    listOf(21      Law("Iso Law: round trip one way") { iso.roundTripOneWay(aGen, eqa) },22      Law("Iso Law: round trip other way") { iso.roundTripOtherWay(bGen, eqb) },23      Law("Iso Law: modify identity is identity") { iso.modifyIdentity(aGen, eqa) },24      Law("Iso Law: compose modify") { iso.composeModify(aGen, funcGen, eqa) },25      Law("Iso Law: consitent set with modify") { iso.consistentSetModify(aGen, bGen, eqa) }26    )27  public suspend fun <A, B> Iso<A, B>.roundTripOneWay(aGen: Arb<A>, eq: (A, A) -> Boolean): PropertyContext =28    checkAll(aGen) { a ->29      reverseGet(get(a)).equalUnderTheLaw(a, eq)30    }31  public suspend fun <A, B> Iso<A, B>.roundTripOtherWay(bGen: Arb<B>, eq: (B, B) -> Boolean): PropertyContext =32    checkAll(bGen) { b ->33      get(reverseGet(b)).equalUnderTheLaw(b, eq)34    }35  public suspend fun <A, B> Iso<A, B>.modifyIdentity(aGen: Arb<A>, eq: (A, A) -> Boolean): PropertyContext =36    checkAll(aGen) { a ->37      modify(a, ::identity).equalUnderTheLaw(a, eq)38    }39  public suspend fun <A, B> Iso<A, B>.composeModify(aGen: Arb<A>, funcGen: Arb<(B) -> B>, eq: (A, A) -> Boolean): PropertyContext =40    checkAll(aGen, funcGen, funcGen) { a, f, g ->41      modify(modify(a, f), g).equalUnderTheLaw(modify(a, g compose f), eq)42    }43  public suspend fun <A, B> Iso<A, B>.consistentSetModify(aGen: Arb<A>, bGen: Arb<B>, eq: (A, A) -> Boolean): PropertyContext =44    checkAll(aGen, bGen) { a, b ->45      set(b).equalUnderTheLaw(modify(a) { b }, eq)46    }47}

...3import arrow.core.compose4import arrow.core.identity5import arrow.optics.Setter6import io.kotest.property.Arb7import io.kotest.property.PropertyContext8import io.kotest.property.arrow.laws.Law9import io.kotest.property.arrow.laws.equalUnderTheLaw10import io.kotest.property.checkAll11public object SetterLaws {12  public fun <A, B> laws(13    setter: Setter<A, B>,14    aGen: Arb<A>,15    bGen: Arb<B>,16    funcGen: Arb<(B) -> B>,17    eq: (A, A) -> Boolean = { a, b -> a == b }18  ): List<Law> = listOf(19    Law("Setter law: set is idempotent") { setter.setIdempotent(aGen, bGen, eq) },20    Law("Setter law: modify identity") { setter.modifyIdentity(aGen, eq) },21    Law("Setter law: compose modify") { setter.composeModify(aGen, eq, funcGen) },22    Law("Setter law: consistent set modify") { setter.consistentSetModify(aGen, bGen, eq) }23  )24  public suspend fun <A, B> Setter<A, B>.setIdempotent(aGen: Arb<A>, bGen: Arb<B>, eq: (A, A) -> Boolean): PropertyContext =25    checkAll(aGen, bGen) { a, b ->26      set(set(a, b), b).equalUnderTheLaw(set(a, b), eq)27    }28  public suspend fun <A, B> Setter<A, B>.modifyIdentity(aGen: Arb<A>, eq: (A, A) -> Boolean): PropertyContext =29    checkAll(aGen) { a ->30      modify(a, ::identity).equalUnderTheLaw(a, eq)31    }32  public suspend fun <A, B> Setter<A, B>.composeModify(aGen: Arb<A>, eq: (A, A) -> Boolean, funcGen: Arb<(B) -> B>): PropertyContext =33    checkAll(aGen, funcGen, funcGen) { a, f, g ->34      modify(modify(a, f), g).equalUnderTheLaw(modify(a, g compose f), eq)35    }36  public suspend fun <A, B> Setter<A, B>.consistentSetModify(aGen: Arb<A>, bGen: Arb<B>, eq: (A, A) -> Boolean): PropertyContext =37    checkAll(aGen, bGen) { a, b ->38      modify(a) { b }.equalUnderTheLaw(set(a, b), eq)39    }40}...

1@file:Suppress("MemberVisibilityCanBePrivate", "unused")2package io.kotest.property.arrow.core3import arrow.typeclasses.Monoid4import io.kotest.property.Arb5import io.kotest.property.PropertyContext6import io.kotest.property.arbitrary.list7import io.kotest.property.arrow.laws.Law8import io.kotest.property.arrow.laws.equalUnderTheLaw9import io.kotest.property.arrow.laws.shouldBe10import io.kotest.property.checkAll11public object MonoidLaws {12  public fun <F> laws(M: Monoid<F>, GEN: Arb<F>, eq: (F, F) -> Boolean = { a, b -> a == b }): List<Law> =13    SemigroupLaws.laws(M, GEN, eq) +14      listOf(15        Law("Monoid Laws: Left identity") { M.monoidLeftIdentity(GEN, eq) },16        Law("Monoid Laws: Right identity") { M.monoidRightIdentity(GEN, eq) },17        Law("Monoid Laws: combineAll should be derived") { M.combineAllIsDerived(GEN, eq) },18        Law("Monoid Laws: combineAll of empty list is empty") { M.combineAllOfEmptyIsEmpty(eq) }19      )20  public suspend fun <F> Monoid<F>.monoidLeftIdentity(GEN: Arb<F>, eq: (F, F) -> Boolean): PropertyContext =21    checkAll(GEN) { a ->22      (empty().combine(a)).equalUnderTheLaw(a, eq)23    }24  public suspend fun <F> Monoid<F>.monoidRightIdentity(GEN: Arb<F>, eq: (F, F) -> Boolean): PropertyContext =25    checkAll(GEN) { a ->26      a.combine(empty()).equalUnderTheLaw(a, eq)27    }28  public suspend fun <F> Monoid<F>.combineAllIsDerived(GEN: Arb<F>, eq: (F, F) -> Boolean): PropertyContext =29    checkAll(5, Arb.list(GEN)) { list ->30      list.combineAll().equalUnderTheLaw(if (list.isEmpty()) empty() else list.reduce { acc, f -> acc.combine(f) }, eq)31    }32  public fun <F> Monoid<F>.combineAllOfEmptyIsEmpty(eq: (F, F) -> Boolean): Boolean =33    emptyList<F>().combineAll().equalUnderTheLaw(empty(), eq) shouldBe true34}...

1+import io.kotest.core.spec.style.FunSpec2+import io.kotest.matchers.shouldBe3+import io.kotest.property.Arb4+import io.kotest.property.arbitrary.int5+import io.kotest.property.arbitrary.string6+import io.kotest.property.checkAll7+import io.kotest.property.exhaustive.ints8+import io.kotest.property.exhaustive.string9+import io.kotest.property.forAll10+import io.kotest.property.forNone11+import io.kotest.property.forOne12+import io.kotest.property.property13+class PropertyContextTest : FunSpec({14+    test("forAll should pass if all generated values satisfy the predicate") {15+        forAll(Arb.int(0..100)) { i -> i % 2 == 0 }16+    }17+    test("forNone should pass if no generated values satisfy the predicate") {18+        forNone(Arb.int(0..100)) { i -> i % 2 == 1 }19+    }20+    test("forOne should pass if exactly one generated value satisfies the predicate") {21+        forOne(Arb.int(0..100)) { i -> i % 2 == 1 }22+    }23+    test("property should pass if all generated values satisfy the predicate") {24+        property(Arb.int(0..100)) { i -> i % 2 == 0 }25+    }26+    test("checkAll should pass if all generated values satisfy the predicate") {27+        checkAll(Arb.int(0..100)) { i -> i % 2 == 0 }28+    }29+    test("forAll should pass if all generated values satisfy the predicate using string") {30+        forAll(Arb.string(1..100)) { i -> i.length % 2 == 0 }31+    }32+    test("forNone should pass if no generated values satisfy the predicate using string") {33+        forNone(Arb.string(1..100)) { i -> i.length % 2 == 1 }34+    }35+    test("forOne should pass if exactly one generated value satisfies the predicate using string") {36+        forOne(A

1    val propertyContext = PropertyContext(2    propertyContext.forAll(Gen.int()) { i ->3    }4}5fun main() {6    propertyContextExample()7}

1    property("sum of two numbers") {2        forAll { a: Int, b: Int ->3        }4    }5}6@JvmName("sumInt")7fun sum(a: Int, b: Int): Int = a + b8@JvmName("sumLong")9fun sum(a: Long, b: Long): Long = a + b10@JvmName("sumFloat")11fun sum(a: Float, b: Float): Float = a + b12@JvmName("sumDouble")13fun sum(a: Double, b: Double): Double = a + b14@JvmName("sumString")15fun sum(a: String, b: String): String = a + b16@JvmName("sumArray")17fun sum(a: Array<Int>, b: Array<Int>): Array<Int> = a + b18@JvmName("sumList")19fun sum(a: List<Int>, b: List<Int>): List<Int> = a + b20@JvmName("sumSet")21fun sum(a: Set<Int>, b: Set<Int>): Set<Int> = a + b22@JvmName("sumMap")23fun sum(a: Map<String, Int>, b: Map<String, Int>): Map<String, Int> = a + b24@JvmName("sumPair")25fun sum(a: Pair<Int, Int>, b: Pair<Int, Int>): Pair<Int, Int> = a + b26@JvmName("sumTriple")27fun sum(a: Triple<Int, Int, Int>, b: Triple<Int, Int, Int>): Triple<Int, Int, Int> = a + b28@JvmName("sumPairInt")29fun sum(a: Pair<Int, Int>, b: Int): Pair<Int, Int> = a + b30@JvmName("sumPairLong")31fun sum(a: Pair<Long, Long>, b: Long): Pair<Long, Long> = a + b32@JvmName("sumPairFloat")33fun sum(a: Pair<Float, Float>, b: Float): Pair<Float, Float> = a + b34@JvmName("sumPairDouble")35fun sum(a: Pair<Double, Double>, b: Double): Pair<Double, Double> = a + b36@JvmName("sumTripleInt")37fun sum(a: Triple<Int, Int, Int>, b: Int): Triple<Int, Int, Int> = a + b

1    val propContext = PropertyContext()2    val propConfig = PropConfig(3        seed = Random.nextLong(),4    propContext.forAll(propConfig, Arb.string(), Arb.string()) { s1, s2 ->5    }6}7    val propContext = PropertyContext()8    val propConfig = PropConfig(9        seed = Random.nextLong(),10    propContext.forAll(propConfig, Arb.string(), Arb.string()) { s1, s2 ->11    }12}13    val propContext = PropertyContext()14    val propConfig = PropConfig(15        seed = Random.nextLong(),16    propContext.forAll(propConfig, Arb.string(), Arb.string()) { s1, s2 ->17    }18}19    val propContext = PropertyContext()20    val propConfig = PropConfig(21        seed = Random.nextLong(),22    propContext.forAll(propConfig, Arb.string(), Arb.string()) { s1, s2 ->23    }24}25    val propContext = PropertyContext()26    val propConfig = PropConfig(

1    val result = forAll(1000, 100, Gen.int()) { n ->2    }3    println(result)4    val result2 = forAll(1000, 100, Gen.int()) { n ->5    }6    println(result2)7}8fun main() {9    val result = forAll(1000, 100, Gen.int()) { n ->10    }11    println(result)12    val result2 = forAll(1000, 100, Gen.int()) { n ->13    }14    println(result2)15}16val result = forAll(1000, 100, Gen.int()) { n ->17}18println(result)19val result = forAll(1000, 100, Gen.int()) { n ->20}21println(result)

1    property("first property") {2    }3    property("second property") {4    }5}6The following example shows the use of the forAll() function to define a property based test:7class MyPropertyTest : FunSpec({8    property("first property") {9        forAll {10        }11    }12    property("second property") {13        forAll { a: Int, b: Int ->14        }15    }16})17The following example shows the use of the forAll() function to define a property based test:18class MyPropertyTest : FunSpec({

1class PropertyContextTest : StringSpec() {2    init {3        "property context" {4            val context = PropertyContext()5            val randomInt = context.random.nextInt()6            val randomString = context.random.nextString()7            val randomBoolean = context.random.nextBoolean()8            val randomDouble = context.random.nextDouble()9        }10    }11}12class PropertyTestingTest : StringSpec() {13    init {14        "property testing" {15            forAll { a: Int, b: Int ->16            }17        }18    }19}20class PropertyTestingTest : StringSpec() {21    init {22        "property testing" {23            forAll { a: Int, b: Int ->24            }25        }26    }27}28class PropertyTestingTest : StringSpec() {29    init {30        "property testing" {31            forAll { a: Int, b: Int ->32            }33        }34    }35}36class PropertyTestingTest : StringSpec() {37    init {38        "property testing" {39            forAll { a: Int, b: Int ->40            }41        }42    }43}44class PropertyTestingTest : StringSpec() {45    init {46        "property testing" {47            forAll { a: Int, b: Int ->48            }49        }50    }51}52class PropertyTestingTest : StringSpec() {53    init {54        "property testing" {55            forAll { a: Int, b: Int ->56            }57        }58    }59}

1    property("For all strings, the length of the reverse string is the same as the original string") {2        forAll<String> { a -> a.length == a.reversed().length }3    }4}5class StringTest : FunSpec({6    test("For all strings, the length of the reverse string is the same as the original string") {7        forAll<String> { a -> a.length == a.reversed().length }8    }9})10class IntTest : FunSpec({11    test("For all integers, the sum of the integer and its negative is zero") {12        forAll<Int> { a -> a + (-a) == 0 }13    }14})15class LocalDateTest : FunSpec({16    test("For all local dates, the year is always greater than 0") {17        forAll<LocalDate> { a -> a.year > 0 }18    }19})20class PersonTest : FunSpec({21    test("For all persons, the age is always greater than 0") {22        forAll<Person> { a -> a.age > 0 }23    }24})25class PairTest : FunSpec({26    test("For all pairs, the sum of the first and second values is always greater than 0") {27        forAll<Pair<Int, Int>> { a -> a.first + a.second > 0 }28    }29})30class TripleTest : FunSpec({31    test("For all triples, the sum of the first, second, and third values is always greater than 0") {32        forAll<Triple<Int, Int, Int>> { a -> a.first + a.second + a.third > 0 }33    }34})

1+		PropertyContext().forAll<Int> { x ->2+		}3+	}4+}5+PropertyContext().forAll<Int> { x ->6+}7+PropertyTestingConfig(iterations = 1000)8+PropertyTestingConfig(minSuccessful = 1000)9+PropertyTestingConfig(maxDiscardRatio = 10.0)10+PropertyTestingConfig(maxDisc

1+fun <T> forAll(gen: Gen<T>, fn: (T) -> Boolean) {2+    forAll(100, gen, fn)3+}4+fun <T> forAll(iterations: Int, gen: Gen<T>, fn: (T) -> Boolean) {5+    PropertyContext(iterations, gen, fn).assertAll()6+}7+fun <T> forAll(iterations: Int, seed: Long, gen: Gen<T>, fn: (T) -> Boolean) {8+    PropertyContext(iterations, gen, fn, seed).assertAll()9+}10+fun <T> forAll(iterations: Int, attempts: Int, seed: Long, gen: Gen<T>, fn: (T) -> Boolean) {11+    PropertyContext(iterations, attempts, gen, fn, seed).assertAll()12+}13+fun <T> forAll(iterations: Int, attempts: Int, gen: Gen<T>, fn: (T) -> Boolean) {14+    PropertyContext(iterations, attempts, gen, fn).assertAll()15+}16+fun <T> forAll(iterations: Int, attempts: Int, seed: Long, fn: () -> T, predicate: (T) -> Boolean) {17+    PropertyContext(iterations, attempts