kotest-assertions-arrow

alltypes

arrow.core.Either

fun <T> Either<T, Any?>.shouldBeLeft(): Unit
infix inline fun <A> Either<A, *>.shouldBeLeft(fn: (A) -> Unit): Unit
infix fun <A> Either<A, Any?>.shouldBeLeft(a: A): Unit
fun <reified A> Either<Any?, Any?>.shouldBeLeftOfType(): Unit
fun <T> Either<*, T>.shouldBeRight(): Unit
infix inline fun <B> Either<*, B>.shouldBeRight(fn: (B) -> Unit): Unit
infix fun <B> Either<Any?, B>.shouldBeRight(b: B): Unit
fun <T> Either<T, Any?>.shouldNotBeLeft(): Unit
infix fun <A> Either<A, Any?>.shouldNotBeLeft(a: A): Unit
fun <reified A> Either<Any?, Any?>.shouldNotBeLeftOfType(): Unit
fun <T> Either<Any?, T>.shouldNotBeRight(): Unit
infix fun <B> Either<Any?, B>.shouldNotBeRight(b: B): Unit

arrow.core.NonEmptyList

fun <T> NonEmptyList<T>.forAll(fn: (T) -> Unit): Unit
fun <T> NonEmptyList<T>.forAny(f: (T) -> Unit): Unit
fun <T> NonEmptyList<T>.forAtLeast(k: Int, fn: (T) -> Unit): Unit
fun <T> NonEmptyList<T>.forAtLeastOne(f: (T) -> Unit): Unit
fun <T> NonEmptyList<T>.forAtMost(k: Int, fn: (T) -> Unit): Unit
fun <T> NonEmptyList<T>.forAtMostOne(f: (T) -> Unit): Unit
fun <T> NonEmptyList<T>.forExactly(k: Int, fn: (T) -> Unit): Unit
fun <T> NonEmptyList<T>.forNone(f: (T) -> Unit): Unit
fun <T> NonEmptyList<T>.forOne(fn: (T) -> Unit): Unit
fun <T> NonEmptyList<T>.forSome(fn: (T) -> Unit): Unit
infix fun <T> NonEmptyList<T>.shouldBeSingleElement(t: T): Unit
fun <T : Comparable<T>> NonEmptyList<T>.shouldBeSorted(): Unit
fun NonEmptyList<Any>.shouldBeUnique(): Unit
infix fun <T> NonEmptyList<T>.shouldContain(t: T): Unit
fun <T> NonEmptyList<T>.shouldContainAll(vararg ts: T): Unit
infix fun <T> NonEmptyList<T>.shouldContainAll(ts: List<T>): Unit
fun <T> NonEmptyList<T>.shouldContainElementAt(index: Int, element: T): Unit
fun <T> NonEmptyList<T>.shouldContainNoNulls(): Unit
fun <T> NonEmptyList<T>.shouldContainNull(): Unit
fun <T> NonEmptyList<T>.shouldContainOnlyNulls(): Unit
fun NonEmptyList<Any>.shouldHaveDuplicates(): Unit
infix fun NonEmptyList<Any>.shouldHaveSize(size: Int): Unit
infix fun <T> NonEmptyList<T>.shouldNotBeSingleElement(t: T): Unit
fun <T : Comparable<T>> NonEmptyList<T>.shouldNotBeSorted(): Unit
fun NonEmptyList<Any>.shouldNotBeUnique(): Unit
infix fun <T> NonEmptyList<T>.shouldNotContain(t: T): Unit
fun <T> NonEmptyList<T>.shouldNotContainAll(vararg ts: T): Unit
infix fun <T> NonEmptyList<T>.shouldNotContainAll(ts: List<T>): Unit
fun <T> NonEmptyList<T>.shouldNotContainElementAt(index: Int, element: T): Unit
fun <T> NonEmptyList<T>.shouldNotContainNoNulls(): Unit
fun <T> NonEmptyList<T>.shouldNotContainNull(): Unit
fun <T> NonEmptyList<T>.shouldNotContainOnlyNulls(): Unit
fun NonEmptyList<Any>.shouldNotHaveDuplicates(): Unit
infix fun NonEmptyList<Any>.shouldNotHaveSize(size: Int): Unit

arrow.core.Option

fun Option<Any>.shouldBeNone(): Unit
fun Option<*>.shouldBeSome(): Unit
infix fun <T> Option<T>.shouldBeSome(t: T): Unit
infix fun <T> Option<T>.shouldBeSome(fn: (T) -> Unit): Unit
fun Option<Any>.shouldNotBeNone(): Unit
infix fun <T> Option<T>.shouldNotBeSome(t: T): Unit

arrow.core.Validated

fun Validated<*, *>.shouldBeInvalid(): Unit
infix fun <T> Validated<*, T>.shouldBeInvalid(value: T): Unit
infix fun <T> Validated<T, *>.shouldBeInvalid(fn: (Invalid<T>) -> Unit): Unit
fun Validated<*, *>.shouldBeValid(): Unit
infix fun <T> Validated<*, T>.shouldBeValid(value: T): Unit
infix fun <T> Validated<*, T>.shouldBeValid(fn: (Valid<T>) -> Unit): Unit
fun Validated<*, *>.shouldNotBeInvalid(): Unit
fun <T> Validated<*, T>.shouldNotBeInvalid(value: T): Unit
fun <T> Validated<*, T>.shouldNotBeValid(): Unit
infix fun <T> Validated<*, T>.shouldNotBeValid(value: T): Unit

arrow.typeclasses.ApplicativeError

fun <F, E, A> ApplicativeError<F, E>.choose(fe: () -> E, fa: () -> A): Kind<F, A>

interface EqAssertions<A>

abstract fun EQA(): Eq<A>
operator fun <A> invoke(EQA: Eq<A>, f: EqAssertions<A>.() -> Unit): Unit
open infix fun A.shouldBeEqvTo(b: A): Unit
open infix fun A.shouldNotBeEqvTo(b: A): Unit

io.kotest.properties.Gen

fun <A, B> Gen.Companion.either(GA: Gen<A>, GB: Gen<B>): Gen<Either<A, B>>

io.kotest.properties.Gen

fun <reified A> Gen.Companion.nel(GA: Gen<A>, head: A): Gen<NonEmptyList<A>>

io.kotest.properties.Gen

fun <A> Gen.Companion.option(GA: Gen<A>): Gen<Option<A>>

io.kotest.properties.Gen

fun <A, B> Gen.Companion.validated(GA: Gen<A>, GB: Gen<B>, SA: Semigroup<A>): Gen<Validated<A, B>>

@extension interface IOAssertions : TaglessAssertions<ForIO>

open fun AF(): Applicative<ForIO>
open fun <A> Kind<ForIO, A>.blockingValue(): A

interface OrderAssertions<A> : EqAssertions<A>

open fun A.beGreaterThan(b: A): Matcher<A>
open fun A.beGreaterThanOrEqual(b: A): Matcher<A>
open fun A.beSmallerThan(b: A): Matcher<A>
open fun A.beSmallerThanOrEqual(b: A): Matcher<A>
open fun EQA(): Eq<A>
operator fun <A> invoke(OA: Order<A>, f: OrderAssertions<A>.() -> Unit): Unit
abstract fun OA(): Order<A>
open infix fun A.shouldBeGreaterThan(b: A): Unit
open infix fun A.shouldBeGreaterThanOrEqual(b: A): Unit
open infix fun A.shouldBeSmallerThan(b: A): Unit
open infix fun A.shouldBeSmallerThanOrEqual(b: A): Unit

interface TaglessAssertions<F>

abstract fun AF(): Applicative<F>
open fun <A> Kind<F, A>.be(a: A): Kind<F, Matcher<A>>
abstract fun <A> Kind<F, A>.blockingValue(): A
open infix fun <A> Kind<F, A>.shouldBeInterpretedTo(a: A): Unit

package io.kotest.assertions.arrow

arrow.typeclasses.ApplicativeError

fun <F, E, A> ApplicativeError<F, E>.choose(fe: () -> E, fa: () -> A): Kind<F, A>

package io.kotest.assertions.arrow.either

arrow.core.Either

fun <T> Either<T, Any?>.shouldBeLeft(): Unit
infix inline fun <A> Either<A, *>.shouldBeLeft(fn: (A) -> Unit): Unit
infix fun <A> Either<A, Any?>.shouldBeLeft(a: A): Unit
fun <reified A> Either<Any?, Any?>.shouldBeLeftOfType(): Unit
fun <T> Either<*, T>.shouldBeRight(): Unit
infix inline fun <B> Either<*, B>.shouldBeRight(fn: (B) -> Unit): Unit
infix fun <B> Either<Any?, B>.shouldBeRight(b: B): Unit
fun <T> Either<T, Any?>.shouldNotBeLeft(): Unit
infix fun <A> Either<A, Any?>.shouldNotBeLeft(a: A): Unit
fun <reified A> Either<Any?, Any?>.shouldNotBeLeftOfType(): Unit
fun <T> Either<Any?, T>.shouldNotBeRight(): Unit
infix fun <B> Either<Any?, B>.shouldNotBeRight(b: B): Unit

fun <T> beLeft(): Matcher<Either<T, Any?>>
fun <A> beLeft(a: A): Matcher<Either<A, Any?>>
fun <reified A> beLeftOfType(): Matcher<Either<Any?, Any?>>
fun <T> beRight(): Matcher<Either<Any?, T>>
fun <B> beRight(b: B): Matcher<Either<Any?, B>>
io.kotest.properties.Gen

fun <A, B> Gen.Companion.either(GA: Gen<A>, GB: Gen<B>): Gen<Either<A, B>>

package io.kotest.assertions.arrow.eq

interface EqAssertions<A>

abstract fun EQA(): Eq<A>
operator fun <A> invoke(EQA: Eq<A>, f: EqAssertions<A>.() -> Unit): Unit
open infix fun A.shouldBeEqvTo(b: A): Unit
open infix fun A.shouldNotBeEqvTo(b: A): Unit

package io.kotest.assertions.arrow.nel

arrow.core.NonEmptyList

fun <T> NonEmptyList<T>.forAll(fn: (T) -> Unit): Unit
fun <T> NonEmptyList<T>.forAny(f: (T) -> Unit): Unit
fun <T> NonEmptyList<T>.forAtLeast(k: Int, fn: (T) -> Unit): Unit
fun <T> NonEmptyList<T>.forAtLeastOne(f: (T) -> Unit): Unit
fun <T> NonEmptyList<T>.forAtMost(k: Int, fn: (T) -> Unit): Unit
fun <T> NonEmptyList<T>.forAtMostOne(f: (T) -> Unit): Unit
fun <T> NonEmptyList<T>.forExactly(k: Int, fn: (T) -> Unit): Unit
fun <T> NonEmptyList<T>.forNone(f: (T) -> Unit): Unit
fun <T> NonEmptyList<T>.forOne(fn: (T) -> Unit): Unit
fun <T> NonEmptyList<T>.forSome(fn: (T) -> Unit): Unit
infix fun <T> NonEmptyList<T>.shouldBeSingleElement(t: T): Unit
fun <T : Comparable<T>> NonEmptyList<T>.shouldBeSorted(): Unit
fun NonEmptyList<Any>.shouldBeUnique(): Unit
infix fun <T> NonEmptyList<T>.shouldContain(t: T): Unit
fun <T> NonEmptyList<T>.shouldContainAll(vararg ts: T): Unit
infix fun <T> NonEmptyList<T>.shouldContainAll(ts: List<T>): Unit
fun <T> NonEmptyList<T>.shouldContainElementAt(index: Int, element: T): Unit
fun <T> NonEmptyList<T>.shouldContainNoNulls(): Unit
fun <T> NonEmptyList<T>.shouldContainNull(): Unit
fun <T> NonEmptyList<T>.shouldContainOnlyNulls(): Unit
fun NonEmptyList<Any>.shouldHaveDuplicates(): Unit
infix fun NonEmptyList<Any>.shouldHaveSize(size: Int): Unit
infix fun <T> NonEmptyList<T>.shouldNotBeSingleElement(t: T): Unit
fun <T : Comparable<T>> NonEmptyList<T>.shouldNotBeSorted(): Unit
fun NonEmptyList<Any>.shouldNotBeUnique(): Unit
infix fun <T> NonEmptyList<T>.shouldNotContain(t: T): Unit
fun <T> NonEmptyList<T>.shouldNotContainAll(vararg ts: T): Unit
infix fun <T> NonEmptyList<T>.shouldNotContainAll(ts: List<T>): Unit
fun <T> NonEmptyList<T>.shouldNotContainElementAt(index: Int, element: T): Unit
fun <T> NonEmptyList<T>.shouldNotContainNoNulls(): Unit
fun <T> NonEmptyList<T>.shouldNotContainNull(): Unit
fun <T> NonEmptyList<T>.shouldNotContainOnlyNulls(): Unit
fun NonEmptyList<Any>.shouldNotHaveDuplicates(): Unit
infix fun NonEmptyList<Any>.shouldNotHaveSize(size: Int): Unit

fun <T : Comparable<T>> beSorted(): Matcher<NonEmptyList<T>>
fun <T> contain(t: T): Matcher<NonEmptyList<T>>
fun <T> containAll(vararg ts: T): Matcher<NonEmptyList<T>>
fun <T> containAll(ts: List<T>): Matcher<NonEmptyList<T>>
fun <T> containNoNulls(): Matcher<NonEmptyList<T>>
fun <T> containNull(): Matcher<NonEmptyList<T>>
fun <T> containOnlyNulls(): Matcher<NonEmptyList<T>>
fun <T> haveDuplicates(): Matcher<NonEmptyList<T>>
fun <T> haveElementAt(index: Int, element: T): Matcher<NonEmptyList<T>>
fun <T> haveSize(size: Int): Matcher<NonEmptyList<T>>
io.kotest.properties.Gen

fun <reified A> Gen.Companion.nel(GA: Gen<A>, head: A): Gen<NonEmptyList<A>>

fun <T> singleElement(t: T): Matcher<NonEmptyList<T>>

package io.kotest.assertions.arrow.option

arrow.core.Option

fun Option<Any>.shouldBeNone(): Unit
fun Option<*>.shouldBeSome(): Unit
infix fun <T> Option<T>.shouldBeSome(t: T): Unit
infix fun <T> Option<T>.shouldBeSome(fn: (T) -> Unit): Unit
fun Option<Any>.shouldNotBeNone(): Unit
infix fun <T> Option<T>.shouldNotBeSome(t: T): Unit

fun beNone(): Matcher<Option<Any>>
fun beSome(): Matcher<Option<*>>
fun <T> beSome(t: T): Matcher<Option<T>>
io.kotest.properties.Gen

fun <A> Gen.Companion.option(GA: Gen<A>): Gen<Option<A>>

package io.kotest.assertions.arrow.order

interface OrderAssertions<A> : EqAssertions<A>

open fun A.beGreaterThan(b: A): Matcher<A>
open fun A.beGreaterThanOrEqual(b: A): Matcher<A>
open fun A.beSmallerThan(b: A): Matcher<A>
open fun A.beSmallerThanOrEqual(b: A): Matcher<A>
open fun EQA(): Eq<A>
operator fun <A> invoke(OA: Order<A>, f: OrderAssertions<A>.() -> Unit): Unit
abstract fun OA(): Order<A>
open infix fun A.shouldBeGreaterThan(b: A): Unit
open infix fun A.shouldBeGreaterThanOrEqual(b: A): Unit
open infix fun A.shouldBeSmallerThan(b: A): Unit
open infix fun A.shouldBeSmallerThanOrEqual(b: A): Unit

package io.kotest.assertions.arrow.refinements

fun <F, A> A.beRefinedBy(refinement: Refinement<F, A>): Matcher<A>
fun <F, A> forAll(GA: Gen<A>, refinement: Refinement<F, A>, f: (A) -> Boolean): Unit
infix fun <F, A> A.shouldBeRefinedBy(refinement: Refinement<F, A>): Unit

package io.kotest.assertions.arrow.tagless

@extension interface IOAssertions : TaglessAssertions<ForIO>

open fun AF(): Applicative<ForIO>
open fun <A> Kind<ForIO, A>.blockingValue(): A

interface TaglessAssertions<F>

abstract fun AF(): Applicative<F>
open fun <A> Kind<F, A>.be(a: A): Kind<F, Matcher<A>>
abstract fun <A> Kind<F, A>.blockingValue(): A
open infix fun <A> Kind<F, A>.shouldBeInterpretedTo(a: A): Unit

package io.kotest.assertions.arrow.validation

arrow.core.Validated

fun Validated<*, *>.shouldBeInvalid(): Unit
infix fun <T> Validated<*, T>.shouldBeInvalid(value: T): Unit
infix fun <T> Validated<T, *>.shouldBeInvalid(fn: (Invalid<T>) -> Unit): Unit
fun Validated<*, *>.shouldBeValid(): Unit
infix fun <T> Validated<*, T>.shouldBeValid(value: T): Unit
infix fun <T> Validated<*, T>.shouldBeValid(fn: (Valid<T>) -> Unit): Unit
fun Validated<*, *>.shouldNotBeInvalid(): Unit
fun <T> Validated<*, T>.shouldNotBeInvalid(value: T): Unit
fun <T> Validated<*, T>.shouldNotBeValid(): Unit
infix fun <T> Validated<*, T>.shouldNotBeValid(value: T): Unit

fun <A> beInvalid(): Matcher<Validated<*, A>>
fun <A> beInvalid(a: A): Matcher<Validated<*, A>>
fun <A> beValid(): Matcher<Validated<*, A>>
fun <A> beValid(a: A): Matcher<Validated<*, A>>
io.kotest.properties.Gen

fun <A, B> Gen.Companion.validated(GA: Gen<A>, GB: Gen<B>, SA: Semigroup<A>): Gen<Validated<A, B>>