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

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.

anyVarargs

inline fun <T> MokkeryMatcherScope.~~anyVarargs~~(): Array<T>

Matches any sequence of varargs.

anyVarargsBoolean

fun MokkeryMatcherScope.~~anyVarargsBoolean~~(): BooleanArray

anyVarargs variant for BooleanArray.

anyVarargsByte

fun MokkeryMatcherScope.~~anyVarargsByte~~(): ByteArray

anyVarargs variant for ByteArray.

anyVarargsChar

fun MokkeryMatcherScope.~~anyVarargsChar~~(): CharArray

anyVarargs variant for CharArray.

anyVarargsDouble

fun MokkeryMatcherScope.~~anyVarargsDouble~~(): DoubleArray

anyVarargs variant for DoubleArray.

anyVarargsFloat

fun MokkeryMatcherScope.~~anyVarargsFloat~~(): FloatArray

anyVarargs variant for FloatArray.

anyVarargsInt

fun MokkeryMatcherScope.~~anyVarargsInt~~(): IntArray

anyVarargs variant for IntArray.

anyVarargsLong

fun MokkeryMatcherScope.~~anyVarargsLong~~(): LongArray

anyVarargs variant for LongArray.

anyVarargsShort

fun MokkeryMatcherScope.~~anyVarargsShort~~(): ShortArray

anyVarargs variant for ShortArray.

anyVarargsUByte

fun MokkeryMatcherScope.~~anyVarargsUByte~~(): UByteArray

anyVarargs variant for UByteArray.

anyVarargsUInt

fun MokkeryMatcherScope.~~anyVarargsUInt~~(): IntArray

anyVarargs variant for UIntArray.

anyVarargsULong

fun MokkeryMatcherScope.~~anyVarargsULong~~(): ULongArray

anyVarargs variant for ULongArray.

anyVarargsUShort

fun MokkeryMatcherScope.~~anyVarargsUShort~~(): UShortArray

anyVarargs variant for UShortArray.

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> MokkeryMatcherScope.eq(value: T): T

DEPRECATED: This API is considered obsolete. Simply omit this matcher.

eqRef

fun <T> MokkeryMatcherScope.~~eqRef~~(value: T): T

DEPRECATED: Renamed to ref.

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(vararg values: T): T

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

Matches argument that is present in values.

isNotIn

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

fun <T> MokkeryMatcherScope.isNotIn(values: Iterable<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.

matching

fun <T> MokkeryMatcherScope.~~matching~~(predicate: (T) -> Boolean): T

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

DEPRECATED: This API is considered obsolete. Use matches instead.

matchingBy

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

DEPRECATED: Renamed to matchesBy

neq

fun <T> MokkeryMatcherScope.~~neq~~(value: T): T

Matches an argument that is not equal to value.

neqRef

fun <T> MokkeryMatcherScope.~~neqRef~~(value: T): T

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

not

fun <T> MokkeryMatcherScope.not(matcher: T): T

Matches argument that does not satisfy matcher.

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.

varargsAll

inline fun <T> MokkeryMatcherScope.~~varargsAll~~(noinline predicate: (T) -> Boolean): Array<T>

Matches a sequence of varargs with all elements satisfying the given predicate.

varargsAny

inline fun <T> MokkeryMatcherScope.~~varargsAny~~(noinline predicate: (T) -> Boolean): Array<T>

Matches a sequence of varargs with any element satisfying the given predicate.

varargsBooleanAll

fun MokkeryMatcherScope.~~varargsBooleanAll~~(predicate: (Boolean) -> Boolean): BooleanArray

varargsAll variant for BooleanArray.

varargsBooleanAny

fun MokkeryMatcherScope.~~varargsBooleanAny~~(predicate: (Boolean) -> Boolean): BooleanArray

varargsAny variant for BooleanArray.

varargsByteAll

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

varargsAll variant for ByteArray.

varargsByteAny

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

varargsAny variant for ByteArray.

varargsCharAll

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

varargsAll variant for CharArray.

varargsCharAny

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

varargsAny variant for CharArray.

varargsDoubleAll

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

varargsAll variant for DoubleArray.

varargsDoubleAny

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

varargsAny variant for DoubleArray.

varargsFloatAll

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

varargsAll variant for FloatArray.

varargsFloatAny

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

varargsAny variant for FloatArray.

varargsIntAll

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

varargsAll variant for IntArray.

varargsIntAny

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

varargsAny variant for IntArray.

varargsLongAll

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

varargsAll variant for LongArray.

varargsLongAny

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

varargsAny variant for LongArray.

varargsShortAll

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

varargsAll variant for ShortArray.

varargsShortAny

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

varargsAny variant for ShortArray.

varargsUByteAll

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

varargsAll variant for UByteArray.

varargsUByteAny

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

varargsAny variant for UByteArray.

varargsUIntAll

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

varargsAll variant for UIntArray.

varargsUIntAny

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

varargsAny variant for UIntArray.

varargsULongAll

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

varargsAll variant for ULongArray.

varargsULongAny

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

varargsAny variant for ULongArray.

varargsUShortAll

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

varargsAll variant for UShortArray.

varargsUShortAny

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

varargsAny variant for UShortArray.