MockKMatcherScope

open class MockKMatcherScope(callRecorder: MockKGateway.CallRecorder, val lambda: CapturingSlot<Function<*>>)

Basic stub/verification scope. Part of DSL.

Inside of the scope you can interact with mocks. You can chain calls to the mock, put argument matchers instead of arguments, capture arguments, combine matchers in and/or/not expressions.

It's not required to specify all arguments as matchers, if the argument value is constant it's automatically replaced with eq() matcher. . Handling arguments that have defaults fetched from function (alike System.currentTimeMillis()) can be an issue, because it's not a constant. Such arguments can always be replaced with some matcher.

Provided information is gathered and associated with mock

Inheritors

MockKVerificationScope

Constructors

MockKMatcherScope

constructor(callRecorder: MockKGateway.CallRecorder, lambda: CapturingSlot<Function<*>>)

Types

DynamicCall

class DynamicCall(val self: Any, val methodName: String, val anyContinuationGen: () -> <Error class: unknown class><out <Error class: unknown class>>)

DynamicCallLong

class DynamicCallLong(val self: Any, val methodName: String, val anyContinuationGen: () -> <Error class: unknown class><out <Error class: unknown class>>)

DynamicSetProperty

class DynamicSetProperty(val self: Any, val name: String)

MockKVarargScope

class MockKVarargScope(val position: Int, val nArgs: Int)

Properties

lambda

val lambda: CapturingSlot<Function<*>>

Functions

allAny

inline fun <T : Any> allAny(): T

and

inline fun <T : Any> and(left: T, right: T): T

Combines two matchers via a logical and.

any

inline fun <T : Any> any(): T

Matches any argument.

fun <T : Any> any(classifier: KClass<T>): T

Matches any argument given a KClass

anyBooleanVararg

inline fun anyBooleanVararg(): <Error class: unknown class>

anyByteVararg

inline fun anyByteVararg(): <Error class: unknown class>

anyCharVararg

inline fun anyCharVararg(): <Error class: unknown class>

anyConstructed

inline fun <T : Any> anyConstructed(): T

anyDoubleVararg

inline fun anyDoubleVararg(): <Error class: unknown class>

anyFloatVararg

inline fun anyFloatVararg(): <Error class: unknown class>

anyIntVararg

inline fun anyIntVararg(): <Error class: unknown class>

anyLongVararg

inline fun anyLongVararg(): <Error class: unknown class>

anyShortVararg

inline fun anyShortVararg(): <Error class: unknown class>

anyVararg

inline fun <T : Any> anyVararg(): Array<T>

array

inline fun <T : Any> array(vararg matchers: Matcher<Any>): T

capture

inline fun <T : Any> capture(lst: CapturingSlot<T>): T

Captures a non-nullable value to a CapturingSlot.

inline fun <T : Any> capture(lst: MutableList<T>): T

captureCoroutine

inline fun <T : Any> captureCoroutine(): T

Captures coroutine. Captured coroutine R>().coInvoke(...) can be used in answer scope.

captureLambda

inline fun <T : Function<*>> captureLambda(): T

Captures lambda function. Captured lambda<(A1, A2, ...) -> R>().invoke(...) can be used in answer scope.

captureNullable

inline fun <T : Any> captureNullable(lst: CapturingSlot<T?>): T?

Captures a nullable value to a CapturingSlot.

inline fun <T : Any> captureNullable(lst: MutableList<T?>): T?

Captures a nullable value to a MutableList.

cmpEq

inline fun <T : Comparable<T>> cmpEq(value: T): T

Matches if the value is equal to the provided value via the compareTo function.

coInvoke

inline fun <T : suspend () -> R, R> coInvoke(): T

inline fun <T : suspend (A1) -> R, R, A1> coInvoke(arg1: A1): T

inline fun <T : suspend (A1, A2) -> R, R, A1, A2> coInvoke(arg1: A1, arg2: A2): T

inline fun <T : suspend (A1, A2, A3) -> R, R, A1, A2, A3> coInvoke(arg1: A1, arg2: A2, arg3: A3): T

inline fun <T : suspend (A1, A2, A3, A4) -> R, R, A1, A2, A3, A4> coInvoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4): T

inline fun <T : suspend (A1, A2, A3, A4, A5) -> R, R, A1, A2, A3, A4, A5> coInvoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5): T

inline fun <T : suspend (A1, A2, A3, A4, A5, A6) -> R, R, A1, A2, A3, A4, A5, A6> coInvoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6): T

inline fun <T : suspend (A1, A2, A3, A4, A5, A6, A7) -> R, R, A1, A2, A3, A4, A5, A6, A7> coInvoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7): T

inline fun <T : suspend (A1, A2, A3, A4, A5, A6, A7, A8) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8> coInvoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8): T

inline fun <T : suspend (A1, A2, A3, A4, A5, A6, A7, A8, A9) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9> coInvoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9): T

inline fun <T : suspend (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> coInvoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10): T

inline fun <T : suspend (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> coInvoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11): T

inline fun <T : suspend (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> coInvoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12): T

inline fun <T : suspend (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> coInvoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13): T

inline fun <T : suspend (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> coInvoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13, arg14: A14): T

inline fun <T : suspend (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> coInvoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13, arg14: A14, arg15: A15): T

inline fun <T : suspend (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> coInvoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13, arg14: A14, arg15: A15, arg16: A16): T

inline fun <T : suspend (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> coInvoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13, arg14: A14, arg15: A15, arg16: A16, arg17: A17): T

inline fun <T : suspend (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> coInvoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13, arg14: A14, arg15: A15, arg16: A16, arg17: A17, arg18: A18): T

inline fun <T : suspend (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> coInvoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13, arg14: A14, arg15: A15, arg16: A16, arg17: A17, arg18: A18, arg19: A19): T

inline fun <T : suspend (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> coInvoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13, arg14: A14, arg15: A15, arg16: A16, arg17: A17, arg18: A18, arg19: A19, arg20: A20): T

inline fun <T : suspend (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> coInvoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13, arg14: A14, arg15: A15, arg16: A16, arg17: A17, arg18: A18, arg19: A19, arg20: A20, arg21: A21): T

inline fun <T : suspend (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> coInvoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13, arg14: A14, arg15: A15, arg16: A16, arg17: A17, arg18: A18, arg19: A19, arg20: A20, arg21: A21, arg22: A22): T

coMatch

inline fun <T : Any> coMatch(noinline matcher: suspend (T) -> Boolean): T

coMatchNullable

inline fun <T : Any> coMatchNullable(noinline matcher: suspend (T?) -> Boolean): T

constructedWith

inline fun <T : Any> constructedWith(vararg matchers: Matcher<*>): T

inline fun <T : Any> eq(value: T, inverse: Boolean = false): T

Matches if the value is equal to the provided value via the deepEquals function.

get

operator fun Any.get(name: String): MockKMatcherScope.DynamicCall

getProperty

infix fun Any.getProperty(name: String): Any?

hint

inline fun <R, T : Any> R.hint(cls: KClass<T>, n: Int = 1): R

invoke

inline fun <T : () -> R, R> invoke(): T

inline fun <T : (A1) -> R, R, A1> invoke(arg1: A1): T

inline fun <T : (A1, A2) -> R, R, A1, A2> invoke(arg1: A1, arg2: A2): T

inline fun <T : (A1, A2, A3) -> R, R, A1, A2, A3> invoke(arg1: A1, arg2: A2, arg3: A3): T

inline fun <T : (A1, A2, A3, A4) -> R, R, A1, A2, A3, A4> invoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4): T

inline fun <T : (A1, A2, A3, A4, A5) -> R, R, A1, A2, A3, A4, A5> invoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5): T

inline fun <T : (A1, A2, A3, A4, A5, A6) -> R, R, A1, A2, A3, A4, A5, A6> invoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6): T

inline fun <T : (A1, A2, A3, A4, A5, A6, A7) -> R, R, A1, A2, A3, A4, A5, A6, A7> invoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7): T

inline fun <T : (A1, A2, A3, A4, A5, A6, A7, A8) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8> invoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8): T

inline fun <T : (A1, A2, A3, A4, A5, A6, A7, A8, A9) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9> invoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9): T

inline fun <T : (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> invoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10): T

inline fun <T : (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> invoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11): T

inline fun <T : (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> invoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12): T

inline fun <T : (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> invoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13): T

inline fun <T : (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> invoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13, arg14: A14): T

inline fun <T : (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> invoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13, arg14: A14, arg15: A15): T

inline fun <T : (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> invoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13, arg14: A14, arg15: A15, arg16: A16): T

inline fun <T : (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> invoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13, arg14: A14, arg15: A15, arg16: A16, arg17: A17): T

inline fun <T : (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> invoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13, arg14: A14, arg15: A15, arg16: A16, arg17: A17, arg18: A18): T

inline fun <T : (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> invoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13, arg14: A14, arg15: A15, arg16: A16, arg17: A17, arg18: A18, arg19: A19): T

inline fun <T : (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> invoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13, arg14: A14, arg15: A15, arg16: A16, arg17: A17, arg18: A18, arg19: A19, arg20: A20): T

inline fun <T : (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> invoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13, arg14: A14, arg15: A15, arg16: A16, arg17: A17, arg18: A18, arg19: A19, arg20: A20, arg21: A21): T

inline fun <T : (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) -> R, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> invoke(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11, arg12: A12, arg13: A13, arg14: A14, arg15: A15, arg16: A16, arg17: A17, arg18: A18, arg19: A19, arg20: A20, arg21: A21, arg22: A22): T

invoke

infix fun Any.invoke(name: String): MockKMatcherScope.DynamicCallLong

invokeNoArgs

infix fun Any.invokeNoArgs(name: String): Any?

isNull

inline fun <T : Any> isNull(inverse: Boolean = false): T

Checks if the value is null.

less

inline fun <T : Comparable<T>> less(value: T, andEquals: Boolean = false): T

Matches if the value is less than the provided value via the compareTo function.

match

inline fun <T : Any> match(matcher: Matcher<T>): T

inline fun <T : Any> match(noinline matcher: (T) -> Boolean): T

fun <T : Any> match(matcher: Matcher<T>, kclass: KClass<T>): T

matchNullable

inline fun <T : Any> matchNullable(noinline matcher: (T?) -> Boolean): T

inline fun <T : Comparable<T>> more(value: T, andEquals: Boolean = false): T

Matches if the value is more than the provided value via the compareTo function.

neq

inline fun <T : Any> neq(value: T): T

Matches if the value is not equal to the provided value via the deepEquals function.

not

inline fun <T : Any> not(value: T): T

Negates the matcher.

nrefEq

inline fun <T : Any> nrefEq(value: T): T

Matches if the value is not equal to the provided value via reference comparison.

ofType

inline fun <T : Any> ofType(): T

Checks if the value belongs to the type.

inline fun <T : Any, R : T> ofType(cls: KClass<R>): T

inline fun <T : Any> or(left: T, right: T): T

Combines two matchers via a logical or.

range

inline fun <T : Comparable<T>> range(from: T, to: T, fromInclusive: Boolean = true, toInclusive: Boolean = true): T

Matches if the value is in range via the compareTo function.

refEq

inline fun <T : Any> refEq(value: T, inverse: Boolean = false): T

Matches if the value is equal to the provided value via reference comparison.

setProperty

infix fun Any.setProperty(name: String): MockKMatcherScope.DynamicSetProperty

varargAll

inline fun <T : Any> varargAll(noinline matcher: MockKMatcherScope.MockKVarargScope.(T) -> Boolean): Array<T>

varargAllBoolean

inline fun varargAllBoolean(noinline matcher: MockKMatcherScope.MockKVarargScope.(Boolean) -> Boolean): <Error class: unknown class>

varargAllByte

inline fun varargAllByte(noinline matcher: MockKMatcherScope.MockKVarargScope.(Byte) -> Boolean): <Error class: unknown class>

varargAllChar

inline fun varargAllChar(noinline matcher: MockKMatcherScope.MockKVarargScope.(Char) -> Boolean): <Error class: unknown class>

varargAllDouble

inline fun varargAllDouble(noinline matcher: MockKMatcherScope.MockKVarargScope.(Double) -> Boolean): <Error class: unknown class>

varargAllFloat

inline fun varargAllFloat(noinline matcher: MockKMatcherScope.MockKVarargScope.(Float) -> Boolean): <Error class: unknown class>

varargAllInt

inline fun varargAllInt(noinline matcher: MockKMatcherScope.MockKVarargScope.(Int) -> Boolean): <Error class: unknown class>

varargAllLong

inline fun varargAllLong(noinline matcher: MockKMatcherScope.MockKVarargScope.(Long) -> Boolean): <Error class: unknown class>

varargAllNullable

inline fun <T : Any> varargAllNullable(noinline matcher: MockKMatcherScope.MockKVarargScope.(T?) -> Boolean): Array<T>

varargAllShort

inline fun varargAllShort(noinline matcher: MockKMatcherScope.MockKVarargScope.(Short) -> Boolean): <Error class: unknown class>

varargAny

inline fun <T : Any> varargAny(noinline matcher: MockKMatcherScope.MockKVarargScope.(T) -> Boolean): Array<T>

varargAnyBoolean

inline fun varargAnyBoolean(noinline matcher: MockKMatcherScope.MockKVarargScope.(Boolean) -> Boolean): <Error class: unknown class>

varargAnyByte

inline fun varargAnyByte(noinline matcher: MockKMatcherScope.MockKVarargScope.(Byte) -> Boolean): <Error class: unknown class>

varargAnyChar

inline fun varargAnyChar(noinline matcher: MockKMatcherScope.MockKVarargScope.(Char) -> Boolean): <Error class: unknown class>

varargAnyDouble

inline fun varargAnyDouble(noinline matcher: MockKMatcherScope.MockKVarargScope.(Double) -> Boolean): <Error class: unknown class>

varargAnyFloat

inline fun varargAnyFloat(noinline matcher: MockKMatcherScope.MockKVarargScope.(Float) -> Boolean): <Error class: unknown class>

varargAnyInt

inline fun varargAnyInt(noinline matcher: MockKMatcherScope.MockKVarargScope.(Int) -> Boolean): <Error class: unknown class>

varargAnyLong

inline fun varargAnyLong(noinline matcher: MockKMatcherScope.MockKVarargScope.(Long) -> Boolean): <Error class: unknown class>

varargAnyNullable

inline fun <T : Any> varargAnyNullable(noinline matcher: MockKMatcherScope.MockKVarargScope.(T?) -> Boolean): Array<T>

varargAnyShort

inline fun varargAnyShort(noinline matcher: MockKMatcherScope.MockKVarargScope.(Short) -> Boolean): <Error class: unknown class>