arrow-core-test/arrow.core.test/UnitSpec

UnitSpec

abstract class UnitSpec(iterations: Int, maxDepth: Int, spec: UnitSpec.() -> Unit) : StringSpec

Base class for unit tests

Constructors

fun UnitSpec(spec: UnitSpec.() -> Unit)

fun UnitSpec(iterations: Int = 250, maxDepth: Int = 15, spec: UnitSpec.() -> Unit = {})

Functions

open override fun add(test: RootTest)

fun afterAny(f: suspend (Tuple2<TestCase, TestResult>) -> Unit)

open fun afterAny(testCase: TestCase, result: TestResult)

fun afterContainer(f: suspend (Tuple2<TestCase, TestResult>) -> Unit)

open fun afterContainer(testCase: TestCase, result: TestResult)

fun afterEach(f: suspend (Tuple2<TestCase, TestResult>) -> Unit)

open fun afterEach(testCase: TestCase, result: TestResult)

fun afterProject(f: AfterProject)

open fun afterSpec(spec: Spec)

open override fun afterSpec(f: suspend (Spec) -> Unit)

open override fun afterTest(f: suspend (Tuple2<TestCase, TestResult>) -> Unit)

open fun afterTest(testCase: TestCase, result: TestResult)

fun appliedTags(): Set<Tag>

~~fun~~ ~~aroundSpec~~(~~aroundSpecFn~~: suspend (Tuple2<KClass<out Spec>, suspend () -> Unit>) -> Unit)

fun aroundTest(aroundTestFn: suspend (Tuple2<TestCase, suspend (TestCase) -> TestResult>) -> TestResult)

inline fun <A> Arb.Companion.array(gen: Arb<A>, range: IntRange = 0..maxDepth): Arb<Array<A>>

open fun assertionMode(): AssertionMode?

fun <T : AutoCloseable> autoClose(closeable: T): T

fun <T : AutoCloseable> autoClose(closeable: Lazy<T>): Lazy<T>

open fun beforeAny(testCase: TestCase)

fun beforeAny(f: suspend (TestCase) -> Unit)

beforeContainer

open fun beforeContainer(testCase: TestCase)

fun beforeContainer(f: suspend (TestCase) -> Unit)

open fun beforeEach(testCase: TestCase)

fun beforeEach(f: suspend (TestCase) -> Unit)

open fun beforeSpec(spec: Spec)

fun beforeSpec(f: suspend (Spec) -> Unit)

open fun beforeTest(testCase: TestCase)

open override fun beforeTest(f: suspend (TestCase) -> Unit)

suspend fun checkAll(property: suspend PropertyContext.() -> Unit): PropertyContext

suspend fun <A> checkAll(genA: Arb<A>, property: suspend PropertyContext.(A) -> Unit): PropertyContext

suspend fun <A, B> checkAll(genA: Arb<A>, genB: Arb<B>, property: suspend PropertyContext.(A, B) -> Unit): PropertyContext

suspend fun <A, B, C> checkAll(genA: Arb<A>, genB: Arb<B>, genC: Arb<C>, property: suspend PropertyContext.(A, B, C) -> Unit): PropertyContext

suspend fun <A, B, C, D> checkAll(genA: Arb<A>, genB: Arb<B>, genC: Arb<C>, genD: Arb<D>, property: suspend PropertyContext.(A, B, C, D) -> Unit): PropertyContext

suspend fun <A, B, C, D, E> checkAll(genA: Arb<A>, genB: Arb<B>, genC: Arb<C>, genD: Arb<D>, genE: Arb<E>, property: suspend PropertyContext.(A, B, C, D, E) -> Unit): PropertyContext

suspend fun <A, B, C, D, E, F> checkAll(genA: Arb<A>, genB: Arb<B>, genC: Arb<C>, genD: Arb<D>, genE: Arb<E>, genF: Arb<F>, property: suspend PropertyContext.(A, B, C, D, E, F) -> Unit): PropertyContext

suspend fun <A, B, C, D, E, F, G> checkAll(gena: Arb<A>, genb: Arb<B>, genc: Arb<C>, gend: Arb<D>, gene: Arb<E>, genf: Arb<F>, geng: Arb<G>, fn: suspend PropertyContext.(A, B, C, D, E, F, G) -> Unit)

suspend fun <A, B, C, D, E, F, G, H> checkAll(gena: Arb<A>, genb: Arb<B>, genc: Arb<C>, gend: Arb<D>, gene: Arb<E>, genf: Arb<F>, geng: Arb<G>, genh: Arb<H>, fn: suspend PropertyContext.(A, B, C, D, E, F, G, H) -> Unit)

suspend fun <A, B, C, D, E, F, G, H, I> checkAll(gena: Arb<A>, genb: Arb<B>, genc: Arb<C>, gend: Arb<D>, gene: Arb<E>, genf: Arb<F>, geng: Arb<G>, genh: Arb<H>, geni: Arb<I>, fn: suspend PropertyContext.(A, B, C, D, E, F, G, H, I) -> Unit)

suspend fun <A, B, C, D, E, F, G, H, I, J> checkAll(gena: Arb<A>, genb: Arb<B>, genc: Arb<C>, gend: Arb<D>, gene: Arb<E>, genf: Arb<F>, geng: Arb<G>, genh: Arb<H>, geni: Arb<I>, genj: Arb<J>, fn: suspend PropertyContext.(A, B, C, D, E, F, G, H, I, J) -> Unit)

open fun concurrency(): Int?

open fun String.config(enabled: Boolean?, invocations: Int?, threads: Int?, tags: Set<Tag>?, timeout: Duration?, extensions: List<TestCaseExtension>?, enabledIf: EnabledIf?, invocationTimeout: Duration?, severity: TestCaseSeverityLevel?, enabledOrReasonIf: EnabledOrReasonIf?, coroutineDebugProbes: Boolean?, blockingTest: Boolean?, test: suspend TestScope.() -> Unit)

coroutineDispatcherFactory

open fun coroutineDispatcherFactory(): CoroutineDispatcherFactory?

defaultTestCaseConfig

~~open~~ ~~fun~~ ~~defaultTestCaseConfig~~(): TestCaseConfig?

dispatcherAffinity

open fun dispatcherAffinity(): Boolean?

fun <T : Extension> extension(extension: T): T

fun extension(f: suspend (Tuple2<TestCase, suspend (TestCase) -> TestResult>) -> TestResult)

open fun extensions(): List<Extension>

fun extensions(vararg extensions: Extension)

fun extensions(extensions: List<Extension>)

fun finalizeSpec(f: suspend (Tuple2<KClass<out Spec>, Map<TestCase, TestResult>>) -> Unit)

suspend fun forFew(iterations: Int, property: suspend PropertyContext.(Unit) -> Unit): PropertyContext

globalExtensions

open override fun globalExtensions(): List<Extension>

fun include(factory: TestFactory)

fun include(prefix: String, factory: TestFactory)

invocationTimeout

open fun invocationTimeout(): Long?

open operator fun String.invoke(test: suspend StringSpecScope.() -> Unit)

open fun isolationMode(): IsolationMode?

fun <A> Arb.Companion.list(gen: Gen<A>, range: IntRange = 0..maxDepth): Arb<List<A>>

fun <T : TestListener> listener(listener: T): T

open fun listeners(): List<TestListener>

fun listeners(vararg listeners: TestListener)

fun listeners(listeners: List<TestListener>)

fun <K, V> Arb.Companion.map(keyArb: Arb<K>, valueArb: Arb<V>, minSize: Int = 1, maxSize: Int = 15): Arb<Map<K, V>>

fun <A> Arb.Companion.nonEmptyList(arb: Arb<A>, depth: Int = maxDepth): Arb<NonEmptyList<A>>

fun <T : TestListener> register(extension: T): T

fun register(vararg extensions: Extension)

fun register(extensions: List<Extension>)

registeredAutoCloseables

fun registeredAutoCloseables(): List<Lazy<AutoCloseable>>

registeredExtensions

fun registeredExtensions(): List<Extension>

open override fun rootTests(): List<RootTest>

fun <A> Arb.Companion.sequence(arbA: Arb<A>, range: IntRange = 0..maxDepth): Arb<Sequence<A>>

open fun tags(): Set<Tag>

fun tags(vararg tags: Tag)

open fun testCaseOrder(): TestCaseOrder?

fun testLaws(vararg laws: List<Law>)

fun testLaws(prefix: String, vararg laws: List<Law>)

open fun threads(): Int?

open fun timeout(): Long?

Properties

var assertions: AssertionMode?

var assertSoftly: Boolean?

var blockingTest: Boolean?

var concurrency: Int?

coroutineDebugProbes

var coroutineDebugProbes: Boolean?

coroutineDispatcherFactory

var coroutineDispatcherFactory: CoroutineDispatcherFactory?

defaultTestConfig

~~var~~ ~~defaultTestConfig~~: TestCaseConfig?

dispatcherAffinity

var dispatcherAffinity: Boolean?

duplicateTestNameMode

var duplicateTestNameMode: DuplicateTestNameMode?

var failfast: Boolean?

invocationTimeout

var invocationTimeout: Long?

var isolationMode: IsolationMode?

val iterations: Int = 250

val maxDepth: Int = 15

var severity: TestCaseSeverityLevel?

testCoroutineDispatcher

var testCoroutineDispatcher: Boolean?

var testOrder: TestCaseOrder?

var threads: Int?

var timeout: Long?