kone.util.assertions/dev.lounres.kone.assertions/Expect

Expect

A type representing a value under assertion.

The Expect interface wraps a value and provides a way to expose it for assertion checks. It serves as the foundation for the assertion DSL, allowing for chained assertion calls in a type-safe manner.

Implementations of this functional interface must provide the exposeValue function, which returns the underlying value being asserted on.

Type Parameters

Value

The type of the value being asserted on. This is a covariant type parameter, allowing for flexible subtyping in assertion chains.

Types

Companion

object Companion

Companion object for the Expect interface, providing factory methods for creating assertions.

Dsl

@DslMarker

annotation class Dsl

DSL marker annotation to prevent unwanted implicit receivers in assertion lambdas.

Functions

assert

context(assertionScope: AssertionScope)
inline fun <Value> Expect<Value>.assert(checker: (Value) -> AssertionScope.Assertion)

Executes the given assertion checker on the value exposed by this Expect instance.

exposeValue

abstract fun exposeValue(): Value

Exposes the underlying value being asserted on.

notToBe

context(assertionScope: AssertionScope)
infix fun Expect<Any?>.notToBe(expected: Any?)

Asserts that the exposed value is not equal to the expected value using == comparison.

notToBeTheSameInstanceAs

context(assertionScope: AssertionScope)
infix fun Expect<Any?>.notToBeTheSameInstanceAs(expected: Any?)

Asserts that the exposed value is not the same instance as the expected value using !== comparison.

toBe

context(assertionScope: AssertionScope)
infix fun Expect<Any?>.toBe(expected: Any?)

Asserts that the exposed value is equal to the expected value using == comparison.

toBeGreaterThan

context(assertionScope: AssertionScope)
infix fun <Element : Comparable<Element>> Expect<Element>.toBeGreaterThan(expected: Element)

Asserts that the exposed value is greater than the expected value.

toBeGreaterThanOrEqualTo

context(assertionScope: AssertionScope)
infix fun <Element : Comparable<Element>> Expect<Element>.toBeGreaterThanOrEqualTo(expected: Element)

Asserts that the exposed value is greater than or equal to the expected value.

toBeLessThan

context(assertionScope: AssertionScope)
infix fun <Element : Comparable<Element>> Expect<Element>.toBeLessThan(expected: Element)

Asserts that the exposed value is less than the expected value.

toBeLessThanOrEqualTo

context(assertionScope: AssertionScope)
infix fun <Element : Comparable<Element>> Expect<Element>.toBeLessThanOrEqualTo(expected: Element)

Asserts that the exposed value is less than or equal to the expected value.

toBeTheSameInstanceAs

context(assertionScope: AssertionScope)
infix fun Expect<Any?>.toBeTheSameInstanceAs(expected: Any?)

Asserts that the exposed value is the same instance as the expected value using === comparison.

using

infix fun <OldValue, NewValue> Expect<OldValue>.using(provider: (OldValue) -> NewValue): Expect<NewValue>

Transforms an Expect assertion from one value type to another using a provider function.

inline fun <OldValue, NewValue> Expect<OldValue>.using(noinline provider: (OldValue) -> NewValue, block: Expect<NewValue>.() -> Unit)

Transforms an Expect assertion from one value type to another using a provider function and executes the assertion block on the transformed value.

usingLazily

infix fun <OldValue, NewValue> Expect<OldValue>.usingLazily(provider: (OldValue) -> NewValue): Expect<NewValue>

Transforms an Expect assertion from one value type to another using a lazily-evaluated provider function.

inline fun <OldValue, NewValue> Expect<OldValue>.usingLazily(noinline provider: (OldValue) -> NewValue, block: Expect<NewValue>.() -> Unit)

Transforms an Expect assertion from one value type to another using a lazily-evaluated provider function and executes the assertion block on the transformed value.