Package io.mockk

Types

Matcher to replace all unspecified argument matchers to any() Handled by logic in a special way

data class AndOrMatcher<T : Any>( val and: Boolean, val first: T, val second: T) : Matcher<T> , CompositeMatcher<T> , CapturingMatcher

Boolean logic "AND" and "OR" matcher composed of two other matchers

Answer

interface Answer<out T>

Provides return value for mocked function

ArrayMatcher

data class ArrayMatcher<in T : Any>(matchers: List<Matcher<Any>>) : Matcher<T> , CapturingMatcher

Matcher that can match arrays via provided matchers for each element.

BackingFieldValue

class BackingFieldValue( val name: String, val getter: () -> Any?, val setter: (Any?) -> Unit)

Manipulable field value

BackingFieldValueProvider

typealias BackingFieldValueProvider = () -> BackingFieldValue?

Call

data class Call( val retType: KClass<*>, val invocation: Invocation, val matcher: InvocationMatcher, val fieldValueProvider: BackingFieldValueProvider)

Call happened for stubbed mock

Called

typealias called = Called

CaptureMatcher

data class CaptureMatcher<T : Any>(val captureList: MutableList<T>, val argumentType: KClass<*>) : Matcher<T> , CapturingMatcher, TypedMatcher, EquivalentMatcher

Matcher capturing all results to the list.

CaptureNullableMatcher

data class CaptureNullableMatcher<T : Any>(val captureList: MutableList<T?>, val argumentType: KClass<*>) : Matcher<T> , CapturingMatcher, TypedMatcher, EquivalentMatcher

Matcher capturing all results to the list. Allows nulls

CapturingMatcher

interface CapturingMatcher

Captures the argument

CapturingSlot

class CapturingSlot<T : Any>

Slot allows to capture one value.

CapturingSlotMatcher

data class CapturingSlotMatcher<T : Any>(val captureSlot: CapturingSlot<T>, val argumentType: KClass<*>) : Matcher<T> , CapturingMatcher, TypedMatcher, EquivalentMatcher

Matcher capturing one last value to the CapturingSlot

CoFunctionAnswer

data class CoFunctionAnswer<T>(val answerFunc: suspend (Call) -> T) : Answer<T>

Delegates reply to the lambda suspendable function

ComparingMatcher

data class ComparingMatcher<T : Comparable<T>>( val value: T, val cmpFunc: Int, val argumentType: KClass<T>) : Matcher<T> , TypedMatcher

Matcher comparing values

CompositeMatcher

interface CompositeMatcher<T>

Matcher composed from several other matchers.

ConstantAnswer

data class ConstantAnswer<T>(val constantValue: T) : Answer<T>

Returns one constant reply

ConstantMatcher

data class ConstantMatcher<in T : Any>(val constValue: Boolean) : Matcher<T>

Matcher that always returns one same value.

CoroutineCall

interface CoroutineCall<T>

Deregisterable

interface Deregisterable

Allows to deregister something was registered before

EqMatcher

data class EqMatcher<in T : Any>( val valueArg: T, val ref: Boolean = false, val inverse: Boolean = false) : Matcher<T>

Matcher that checks equality. By reference and by value (equals method)

EquivalentMatcher

interface EquivalentMatcher

Allows to substitute matcher to find correct chained call

FunctionAnswer

data class FunctionAnswer<T>(val answerFunc: (Call) -> T) : Answer<T>

Delegates reply to the lambda function

FunctionMatcher

data class FunctionMatcher<in T : Any>(val matchingFunc: (T) -> Boolean, val argumentType: KClass<*>) : Matcher<T> , TypedMatcher, EquivalentMatcher

Delegates matching to lambda function

FunctionWithNullableArgMatcher

data class FunctionWithNullableArgMatcher<in T : Any>(val matchingFunc: (T?) -> Boolean, val argumentType: KClass<*>) : Matcher<T> , TypedMatcher, EquivalentMatcher

InternalCounter

interface InternalCounter

InternalPlatformDsl

expect object InternalPlatformDsl

actual object InternalPlatformDsl

InternalRef

interface InternalRef<T>

Invocation

data class Invocation( val self: Any, val stub: Any, val method: MethodDescription, val args: List<Any?>, val timestamp: Long, val callStack: () -> List<StackElement>, val originalCall: () -> Any?, val fieldValueProvider: BackingFieldValueProvider)

Mock invocation

InvocationMatcher

data class InvocationMatcher( val self: Any, val method: MethodDescription, val args: List<Matcher<Any>>, val allAny: Boolean)

Checks if invocation is matching via number of matchers

InvokeMatcher

class InvokeMatcher<in T : Any>(val block: (T) -> Unit) : Matcher<T> , EquivalentMatcher

Invokes lambda

JvmCoroutineCall

class JvmCoroutineCall<T>(lambda: suspend () -> T) : CoroutineCall<T>

ManyAnswerable

interface ManyAnswerable<out T> : Answer<T>

Required to signalize many answers available

ManyAnswersAnswer

data class ManyAnswersAnswer<T>(val answers: List<Answer<T>>) : ManyAnswerable<T>

Returns many different replies, each time moving the next list element. Stops at the end.

Matcher

interface Matcher<in T>

Checks if argument is matching some criteria

MethodDescription

data class MethodDescription( val name: String, val returnType: KClass<*>, val returnTypeNullable: Boolean, val returnsUnit: Boolean, val returnsNothing: Boolean, val isSuspend: Boolean, val isFnCall: Boolean, val declaringClass: KClass<*>, val paramTypes: List<KClass<*>>, val varArgsArg: Int, val privateCall: Boolean)

Provides information about method

MockKAdditionalAnswerScope

class MockKAdditionalAnswerScope<T, B>( answerOpportunity: MockKGateway.AnswerOpportunity<T>, callRecorder: MockKGateway.CallRecorder, lambda: CapturingSlot<Function<*>>)

Scope to chain additional answers to reply. Part of DSL

MockKAnswerScope

class MockKAnswerScope<T, B>(lambda: CapturingSlot<Function<*>>, val call: Call)

Scope for answering functions. Part of DSL

MockKAssertScope

class MockKAssertScope(val actual: Any?)

Part of DSL. Scope for assertions on arguments during verifications.

MockKCancellation

typealias MockKCancellation = () -> Unit

MockKCancellationRegistry

object MockKCancellationRegistry

MockKConstructorScope

class MockKConstructorScope<T : Any>( val type: KClass<T>, val recordPrivateCalls: Boolean, val localToThread: Boolean) : MockKUnmockKScope

Scope for constructor calls. Part of DSL.

MockKDsl

object MockKDsl

DSL entry points.

MockKException

class MockKException(message: String, ex: Throwable? = null) : RuntimeException

Exception thrown by library

MockKGateway

interface MockKGateway

Mediates mocking implementation

MockKMatcherScope

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

Basic stub/verification scope. Part of DSL.

MockKObjectScope

class MockKObjectScope(val objects: Any, val recordPrivateCalls: Boolean = false) : MockKUnmockKScope

Scope for object mockks. Part of DSL

MockKSettings

expect object MockKSettings

actual object MockKSettings

MockKStaticScope

class MockKStaticScope(val staticTypes: KClass<*>) : MockKUnmockKScope

Scope for static mockks. Part of DSL

MockKStubScope

class MockKStubScope<T, B>( answerOpportunity: MockKGateway.AnswerOpportunity<T>, callRecorder: MockKGateway.CallRecorder, lambda: CapturingSlot<Function<*>>)

Stub scope. Part of DSL

MockKUnmockKCompositeScope

class MockKUnmockKCompositeScope(val first: MockKUnmockKScope, val second: MockKUnmockKScope) : MockKUnmockKScope

Composite of two scopes. Part of DSL

MockKUnmockKScope

abstract class MockKUnmockKScope

Cancelable mocking scope

MockKVerificationScope

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

Part of DSL. Additional operations for verification scope.

NotMatcher

data class NotMatcher<T : Any>(val value: T) : Matcher<T> , CompositeMatcher<T> , CapturingMatcher

Boolean logic "NOT" matcher composed of one matcher

NullCheckMatcher

data class NullCheckMatcher<in T : Any>(val inverse: Boolean = false) : Matcher<T>

Checks if argument is null or non-null

OfTypeMatcher

data class OfTypeMatcher<in T : Any>(val cls: KClass<*>) : Matcher<T>

Checks matcher data type

Ordering

enum Ordering : Enum<Ordering>

Verification ordering

RecordedCall

data class RecordedCall( val retValue: Any?, val isRetValueMock: Boolean, val retType: KClass<*>, val matcher: InvocationMatcher, val selfChain: RecordedCall?, val argChains: List<Any>?)

Matched call

Runs

typealias runs = Runs

StackElement

data class StackElement( val className: String, val fileName: String, val methodName: String, val line: Int, val nativeMethod: Boolean)

Element of stack trace.

StackTracesAlignment

enum StackTracesAlignment : Enum<StackTracesAlignment>

ThrowingAnswer

data class ThrowingAnswer(val ex: Throwable) : Answer<Nothing>

Throws exception instead of function reply

TypedMatcher

interface TypedMatcher

Checks if argument is of specific type

VarargMatcher

data class VarargMatcher<T : Any>( all: Boolean, matcher: MockKMatcherScope.MockKVarargScope.(T?) -> Boolean, prefix: List<Matcher<T>> = listOf(), postfix: List<Matcher<T>> = listOf()) : Matcher<Any> , CapturingMatcher

Functions

andThenJust

infix fun MockKAdditionalAnswerScope<Unit, Unit>.andThenJust(runs: Runs): MockKAdditionalAnswerScope<Unit, Unit>

Part of DSL. Answer placeholder for Unit returning functions.

captureSubMatchers

fun CompositeMatcher<*>.captureSubMatchers(arg: Any?)

checkEquals

fun MockKAssertScope.checkEquals(expected: Any?)

fun MockKAssertScope.checkEquals(msg: String, expected: Any?)

coInvoke

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

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

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

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

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

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

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

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

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

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

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> CapturingSlot<T>.coInvoke( arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10): R

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> CapturingSlot<T>.coInvoke( arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

internalSubstitute

fun <T> T.internalSubstitute(map: Map<Any, Any>): T

fun <T : Any> List<T>.internalSubstitute(map: Map<Any, Any>): List<T>

invoke

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

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

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

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

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

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

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

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

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

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

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> CapturingSlot<T>.invoke( arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10): R

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> CapturingSlot<T>.invoke( arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, arg10: A10, arg11: A11): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

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> CapturingSlot<T>.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): R

just

infix fun MockKStubScope<Unit, Unit>.just(runs: Runs): MockKAdditionalAnswerScope<Unit, Unit>

Part of DSL. Answer placeholder for Unit returning functions.

stackTracesAlignmentValueOf

fun stackTracesAlignmentValueOf(property: String): StackTracesAlignment

use

inline fun <T : Deregisterable, R> T.use(block: (T) -> R): R

inline fun <T> MockKUnmockKScope.use(block: () -> T): T

Wraps block of code for safe resource allocation and deallocation. Part of DSL