mokkery-runtime/dev.mokkery.templating/MokkeryTemplatingScope

MokkeryTemplatingScope

interface MokkeryTemplatingScope : MokkeryMatcherScope(source)

Scope for declaring call templates. It's used with dev.mokkery.every and dev.mokkery.verify. Currently, it's illegal to declare functions that accept this scope.

Example of a call template inside verify:

verify {
  mock.call(any())
}

Properties

callHooks

val MokkeryScope.callHooks: MokkeryCallHooks

Returns MokkeryCallHooks associated with this scope. See MokkeryCallHooks for details on hook scoping.

mokkeryContext

abstract val mokkeryContext: MokkeryContext

Functions

and

fun <T> MokkeryMatcherScope.and(first: T, second: T, vararg moreMatchers: T): T

Matches argument that satisfies all the matchers (first, second and all from moreMatchers).

any

fun <T> MokkeryMatcherScope.any(): T

Matches any argument.

capture

fun <T> MokkeryMatcherScope.capture(container: Capture<T>, matcher: T = any()): T

Matches an argument with matcher and captures matching arguments into capture. Arguments are captured only if all other matchers match.

fun <T> MokkeryMatcherScope.capture(list: MutableList<T>, matcher: T = any()): T

Matches an argument with matcher and captures matching arguments into list. Arguments are captured only if all other matchers match.

containsAll

fun <T, R : Iterable<T>> MokkeryMatcherScope.containsAll(predicate: (T) -> Boolean): R

Matches an Iterable with all elements matching predicate

containsAllBooleans

fun MokkeryMatcherScope.containsAllBooleans(predicate: (Boolean) -> Boolean): BooleanArray

Matches a BooleanArray with all elements matching predicate

containsAllBytes

fun MokkeryMatcherScope.containsAllBytes(predicate: (Byte) -> Boolean): ByteArray

Matches a ByteArray with all elements matching predicate

containsAllChars

fun MokkeryMatcherScope.containsAllChars(predicate: (Char) -> Boolean): CharArray

Matches a CharArray with all elements matching predicate

containsAllDoubles

fun MokkeryMatcherScope.containsAllDoubles(predicate: (Double) -> Boolean): DoubleArray

Matches a DoubleArray with all elements matching predicate

containsAllElements

fun <T> MokkeryMatcherScope.containsAllElements(predicate: (T) -> Boolean): Array<T>

Matches an Array with all elements matching predicate

containsAllFloats

fun MokkeryMatcherScope.containsAllFloats(predicate: (Float) -> Boolean): FloatArray

Matches a FloatArray with all elements matching predicate

containsAllInts

fun MokkeryMatcherScope.containsAllInts(predicate: (Int) -> Boolean): IntArray

Matches a IntArray with all elements matching predicate

containsAllLongs

fun MokkeryMatcherScope.containsAllLongs(predicate: (Long) -> Boolean): LongArray

Matches a LongArray with all elements matching predicate

containsAllShorts

fun MokkeryMatcherScope.containsAllShorts(predicate: (Short) -> Boolean): ShortArray

Matches a ShortArray with all elements matching predicate

containsAllUBytes

fun MokkeryMatcherScope.containsAllUBytes(predicate: (UByte) -> Boolean): UByteArray

Matches a UByteArray with all elements matching predicate

containsAllUInts

fun MokkeryMatcherScope.containsAllUInts(predicate: (UInt) -> Boolean): UIntArray

Matches a UIntArray with all elements matching predicate

containsAllULongs

fun MokkeryMatcherScope.containsAllULongs(predicate: (ULong) -> Boolean): ULongArray

Matches a ULongArray with all elements matching predicate

containsAllUShorts

fun MokkeryMatcherScope.containsAllUShorts(predicate: (UShort) -> Boolean): UShortArray

Matches a UShortArray with all elements matching predicate

containsAny

fun <T, R : Iterable<T>> MokkeryMatcherScope.containsAny(predicate: (T) -> Boolean): R

Matches an Iterable with any element matching predicate

containsAnyBoolean

fun MokkeryMatcherScope.containsAnyBoolean(predicate: (Boolean) -> Boolean): BooleanArray

Matches a BooleanArray with any element matching predicate

containsAnyByte

fun MokkeryMatcherScope.containsAnyByte(predicate: (Byte) -> Boolean): ByteArray

Matches a ByteArray with any element matching predicate

containsAnyChar

fun MokkeryMatcherScope.containsAnyChar(predicate: (Char) -> Boolean): CharArray

Matches a CharArray with any element matching predicate

containsAnyDouble

fun MokkeryMatcherScope.containsAnyDouble(predicate: (Double) -> Boolean): DoubleArray

Matches a DoubleArray with any element matching predicate

containsAnyElement

fun <T> MokkeryMatcherScope.containsAnyElement(predicate: (T) -> Boolean): Array<T>

Matches an Array with any element matching predicate

containsAnyFloat

fun MokkeryMatcherScope.containsAnyFloat(predicate: (Float) -> Boolean): FloatArray

Matches a FloatArray with any element matching predicate

containsAnyInt

fun MokkeryMatcherScope.containsAnyInt(predicate: (Int) -> Boolean): IntArray

Matches an IntArray with any element matching predicate

containsAnyLong

fun MokkeryMatcherScope.containsAnyLong(predicate: (Long) -> Boolean): LongArray

Matches a LongArray with any element matching predicate

containsAnyShort

fun MokkeryMatcherScope.containsAnyShort(predicate: (Short) -> Boolean): ShortArray

Matches a ShortArray with any element matching predicate

containsAnyUByte

fun MokkeryMatcherScope.containsAnyUByte(predicate: (UByte) -> Boolean): UByteArray

Matches a UByteArray with any element matching predicate

containsAnyUInt

fun MokkeryMatcherScope.containsAnyUInt(predicate: (UInt) -> Boolean): UIntArray

Matches a UIntArray with any element matching predicate

containsAnyULong

fun MokkeryMatcherScope.containsAnyULong(predicate: (ULong) -> Boolean): ULongArray

Matches a ULongArray with any element matching predicate

containsAnyUShort

fun MokkeryMatcherScope.containsAnyUShort(predicate: (UShort) -> Boolean): UShortArray

Matches a UShortArray with any element matching predicate

contentDeepEq

fun <T> MokkeryMatcherScope.contentDeepEq(array: Array<T>): Array<T>

Matches an Array that is equal to array with contentDeepEquals.

contentEq

fun <T> MokkeryMatcherScope.contentEq(array: Array<T>): Array<T>

Matches an Array that has the same content as array.

fun MokkeryMatcherScope.contentEq(array: BooleanArray): BooleanArray

Matches an BooleanArray that has the same content as array.

fun MokkeryMatcherScope.contentEq(array: ByteArray): ByteArray

Matches an ByteArray that has the same content as array.

fun MokkeryMatcherScope.contentEq(array: CharArray): CharArray

Matches an CharArray that has the same content as array.

fun MokkeryMatcherScope.contentEq(array: DoubleArray): DoubleArray

Matches an DoubleArray that has the same content as array.

fun MokkeryMatcherScope.contentEq(array: FloatArray): FloatArray

Matches an FloatArray that has the same content as array.

fun MokkeryMatcherScope.contentEq(array: IntArray): IntArray

Matches an IntArray that has the same content as array.

fun MokkeryMatcherScope.contentEq(array: LongArray): LongArray

Matches an LongArray that has the same content as array.

fun MokkeryMatcherScope.contentEq(array: ShortArray): ShortArray

Matches an ShortArray that has the same content as array.

fun MokkeryMatcherScope.contentEq(array: UByteArray): UByteArray

Matches an UByteArray that has the same content as array.

fun MokkeryMatcherScope.contentEq(array: UIntArray): UIntArray

Matches an UIntArray that has the same content as array.

fun MokkeryMatcherScope.contentEq(array: ULongArray): ULongArray

Matches an ULongArray that has the same content as array.

fun MokkeryMatcherScope.contentEq(array: UShortArray): UShortArray

Matches an UShortArray that has the same content as array.

fun <T : Comparable<T>> MokkeryMatcherScope.gt(value: T): T

Matches argument that is greater than value.

gte

fun <T : Comparable<T>> MokkeryMatcherScope.gte(value: T): T

Matches an argument that is greater than or equal to value.

isIn

fun <T> MokkeryMatcherScope.isIn(values: Iterable<T>): T

fun <T> MokkeryMatcherScope.isIn(vararg values: T): T

Matches argument that is present in values.

isNotIn

fun <T> MokkeryMatcherScope.isNotIn(values: Iterable<T>): T

fun <T> MokkeryMatcherScope.isNotIn(vararg values: T): T

Matches argument that is not present in values.

fun <T : Comparable<T>> MokkeryMatcherScope.lt(value: T): T

Matches argument that is less than value.

lte

fun <T : Comparable<T>> MokkeryMatcherScope.lte(value: T): T

Matches an argument that is less than or equal to value.

matches

fun <T> MokkeryMatcherScope.matches(matcher: ArgMatcher<T>): T

Matches argument that satisfies a matcher. Cannot be used with ArgMatcher.Composite. Use matchesComposite instead.

fun <T> MokkeryMatcherScope.matches(toString: () -> String, predicate: (T) -> Boolean): T

Matches an argument according to the predicate. Registered matcher Any.toString calls toString.

matchesBy

fun <T> MokkeryMatcherScope.matchesBy(function: (T) -> Boolean): T

Matches an argument by calling given function. Also, it returns function name on Any.toString.

matchesComposite

@DelicateMokkeryApi

fun <T : R, R> MokkeryMatcherScope.matchesComposite(vararg matchers: T, builder: (List<ArgMatcher<T>>) -> ArgMatcher.Composite<R>): R

Matches an argument that satisfies a matcher composed of matchers with builder.

not

fun <T> MokkeryMatcherScope.not(matcher: T, vararg moreMatchers: T): T

Matches argument that does not satisfy all given matchers (matcher and moreMatchers).

notNull

fun <T : Any> MokkeryMatcherScope.notNull(matcher: T = any()): T?

Matches an argument that is not null and matches matcher.

ofType

inline fun <T> MokkeryMatcherScope.ofType(): T

Matches an argument that is an instance of type T.

onArg

fun <T> MokkeryMatcherScope.onArg(matcher: T = any(), block: (T) -> Unit): T

Short for capture with Capture.callback.

fun <T> MokkeryMatcherScope.or(first: T, second: T, vararg moreMatchers: T): T

Matches argument that satisfies any matcher (first, second or any from moreMatchers).

ref

fun <T> MokkeryMatcherScope.ref(value: T): T

Matches an argument whose reference is equal to value's reference.