From 8f1f7a2aa62a760c43d5709d58adb16ac81df897 Mon Sep 17 00:00:00 2001
From: Mark Koops <mark.koops@gmail.com>
Date: Sun, 2 Nov 2025 16:41:20 +0100
Subject: [PATCH] Revamp of ongoing stubbing for suspend functions, by
 introducing CoroutinesOngoingStubbing as return value of the
 wheneverBlocking/onBlocking functions. Introducing this coroutines specific
 implementation of OngoingStubbing allowed for clean and similar API to stub
 either synchronous or suspend functions. The 'magic' implementation details
 of applying SuspendableAnswer for suspend functions and to delay within the
 answer suspend lambda to enforce proper boxing of value classes is all being
 hidden away from the ordinary users.

---
 .idea/codeStyles/Project.xml                  |  37 +-
 .../kotlin/CoroutinesOngoingStubbing.kt       | 213 +++++++
 .../org/mockito/kotlin/KInvocationOnMock.kt   |  56 +-
 .../kotlin/org/mockito/kotlin/KStubbing.kt    | 103 +++-
 .../org/mockito/kotlin/OngoingStubbing.kt     |  39 +-
 .../main/kotlin/org/mockito/kotlin/Stubber.kt |  14 +-
 .../kotlin/org/mockito/kotlin/Whenever.kt     |  70 +++
 .../org/mockito/kotlin/internal/KAnswer.kt    |   4 +-
 .../kotlin/internal/OngoingStubbingUtil.kt    |  80 +++
 .../src/test/kotlin/test/CoroutinesTest.kt    | 537 ------------------
 tests/build.gradle                            |   2 +-
 .../mockito/kotlin/internal/KAnswerTest.kt    | 141 +++++
 .../kotlin/test/AdditionalMatchersTest.kt     |  36 +-
 .../test/kotlin/test/ArgumentCaptorTest.kt    |  28 +-
 tests/src/test/kotlin/test/BDDMockitoTest.kt  |  22 +-
 tests/src/test/kotlin/test/Classes.kt         |  28 +-
 .../test/CoroutinesOngoingStubbingTest.kt     | 344 +++++++++++
 tests/src/test/kotlin/test/CoroutinesTest.kt  | 513 +++++++++++++++++
 tests/src/test/kotlin/test/JUnit4Utils.kt     |  13 +
 tests/src/test/kotlin/test/MatchersTest.kt    | 188 +++---
 tests/src/test/kotlin/test/MockingTest.kt     |  72 ++-
 .../test/kotlin/test/OngoingStubbingTest.kt   | 321 +++++++----
 tests/src/test/kotlin/test/StubberTest.kt     |  14 +-
 tests/src/test/kotlin/test/StubbingTest.kt    | 261 +++++++++
 .../src/test/kotlin/test/VerificationTest.kt  |  16 +-
 25 files changed, 2227 insertions(+), 925 deletions(-)
 create mode 100644 mockito-kotlin/src/main/kotlin/org/mockito/kotlin/CoroutinesOngoingStubbing.kt
 create mode 100644 mockito-kotlin/src/main/kotlin/org/mockito/kotlin/Whenever.kt
 create mode 100644 mockito-kotlin/src/main/kotlin/org/mockito/kotlin/internal/OngoingStubbingUtil.kt
 delete mode 100644 mockito-kotlin/src/test/kotlin/test/CoroutinesTest.kt
 create mode 100644 tests/src/test/kotlin/org/mockito/kotlin/internal/KAnswerTest.kt
 create mode 100644 tests/src/test/kotlin/test/CoroutinesOngoingStubbingTest.kt
 create mode 100644 tests/src/test/kotlin/test/CoroutinesTest.kt
 create mode 100644 tests/src/test/kotlin/test/JUnit4Utils.kt
 create mode 100644 tests/src/test/kotlin/test/StubbingTest.kt

diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index 69f8a38d..704de466 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -31,6 +31,30 @@
     <AndroidXmlCodeStyleSettings>
       <option name="USE_CUSTOM_SETTINGS" value="true" />
     </AndroidXmlCodeStyleSettings>
+    <DBN-PSQL>
+      <case-options enabled="true">
+        <option name="KEYWORD_CASE" value="lower" />
+        <option name="FUNCTION_CASE" value="lower" />
+        <option name="PARAMETER_CASE" value="lower" />
+        <option name="DATATYPE_CASE" value="lower" />
+        <option name="OBJECT_CASE" value="preserve" />
+      </case-options>
+      <formatting-settings enabled="false" />
+    </DBN-PSQL>
+    <DBN-SQL>
+      <case-options enabled="true">
+        <option name="KEYWORD_CASE" value="lower" />
+        <option name="FUNCTION_CASE" value="lower" />
+        <option name="PARAMETER_CASE" value="lower" />
+        <option name="DATATYPE_CASE" value="lower" />
+        <option name="OBJECT_CASE" value="preserve" />
+      </case-options>
+      <formatting-settings enabled="false">
+        <option name="STATEMENT_SPACING" value="one_line" />
+        <option name="CLAUSE_CHOP_DOWN" value="chop_down_if_statement_long" />
+        <option name="ITERATION_ELEMENTS_WRAPPING" value="chop_down_if_not_single" />
+      </formatting-settings>
+    </DBN-SQL>
     <JavaCodeStyleSettings>
       <option name="CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND" value="99" />
       <option name="NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND" value="99" />
@@ -61,10 +85,9 @@
       </option>
     </JavaCodeStyleSettings>
     <JetCodeStyleSettings>
+      <option name="NAME_COUNT_TO_USE_STAR_IMPORT" value="2147483647" />
+      <option name="NAME_COUNT_TO_USE_STAR_IMPORT_FOR_MEMBERS" value="2147483647" />
       <option name="IMPORT_NESTED_CLASSES" value="true" />
-      <option name="CONTINUATION_INDENT_IN_PARAMETER_LISTS" value="false" />
-      <option name="CONTINUATION_INDENT_FOR_EXPRESSION_BODIES" value="false" />
-      <option name="CONTINUATION_INDENT_FOR_CHAINED_CALLS" value="false" />
     </JetCodeStyleSettings>
     <Objective-C-extensions>
       <file>
@@ -95,7 +118,6 @@
       <option name="XML_KEEP_LINE_BREAKS" value="false" />
       <option name="XML_ALIGN_ATTRIBUTES" value="false" />
       <option name="XML_SPACE_INSIDE_EMPTY_TAG" value="true" />
-      <option name="XML_LEGACY_SETTINGS_IMPORTED" value="true" />
     </XML>
     <codeStyleSettings language="JAVA">
       <indentOptions>
@@ -261,13 +283,6 @@
     </codeStyleSettings>
     <codeStyleSettings language="kotlin">
       <option name="ALIGN_MULTILINE_PARAMETERS_IN_CALLS" value="true" />
-      <option name="CALL_PARAMETERS_WRAP" value="5" />
-      <option name="CALL_PARAMETERS_LPAREN_ON_NEXT_LINE" value="true" />
-      <option name="CALL_PARAMETERS_RPAREN_ON_NEXT_LINE" value="true" />
-      <option name="METHOD_PARAMETERS_WRAP" value="5" />
-      <option name="METHOD_PARAMETERS_LPAREN_ON_NEXT_LINE" value="true" />
-      <option name="METHOD_PARAMETERS_RPAREN_ON_NEXT_LINE" value="true" />
-      <option name="EXTENDS_LIST_WRAP" value="1" />
       <indentOptions>
         <option name="CONTINUATION_INDENT_SIZE" value="6" />
       </indentOptions>
diff --git a/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/CoroutinesOngoingStubbing.kt b/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/CoroutinesOngoingStubbing.kt
new file mode 100644
index 00000000..e87b2dac
--- /dev/null
+++ b/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/CoroutinesOngoingStubbing.kt
@@ -0,0 +1,213 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2018 Niek Haarman
+ * Copyright (c) 2007 Mockito contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package org.mockito.kotlin
+
+import kotlinx.coroutines.delay
+import org.mockito.internal.stubbing.answers.Returns
+import org.mockito.kotlin.internal.SuspendableAnswer
+import org.mockito.kotlin.internal.lastInvocationMethodIsSuspend
+import org.mockito.stubbing.Answer
+import org.mockito.stubbing.OngoingStubbing
+import kotlin.reflect.KClass
+
+class CoroutinesOngoingStubbing<T>(val mockitoOngoingStubbing: OngoingStubbing<T>) {
+    /**
+     * Sets a return value to be returned when the method is called.
+     *
+     * Alias for [thenReturn].
+     */
+    infix fun doReturn(t: T): CoroutinesOngoingStubbing<T> {
+        return thenReturn(t)
+    }
+
+    /**
+     * Sets a return value to be returned when the method is called.
+     */
+    @Suppress("UNCHECKED_CAST")
+    infix fun thenReturn(t: T): CoroutinesOngoingStubbing<T> {
+        return thenAnswer(Returns(t))
+    }
+
+    /**
+     * Sets an answer for the suspendable function using a suspendable lambda.
+     *
+     * Alias for [thenAnswer].
+     */
+    infix fun doAnswer(answer: suspend (KInvocationOnMock) -> T?): CoroutinesOngoingStubbing<T> {
+        return thenAnswer(answer)
+    }
+
+    /**
+     * Sets an answer for the suspendable function using a suspendable lambda.
+     *
+     * Alias for [thenAnswer].
+     *
+     * This deprecated method was added for backwards compatibility.
+     */
+    @Deprecated(
+        " use doAnswer() or thenAnswer() instead.",
+        level = DeprecationLevel.WARNING
+    )
+    infix fun doSuspendableAnswer(answer: suspend (KInvocationOnMock) -> T?): CoroutinesOngoingStubbing<T> {
+        return thenAnswer(answer)
+    }
+
+    /**
+     * Sets an answer for the suspendable function using a suspendable lambda.
+     */
+    infix fun thenAnswer(answer: suspend (KInvocationOnMock) -> T?): CoroutinesOngoingStubbing<T> {
+        return thenAnswer(SuspendableAnswer(answer))
+    }
+
+    /**
+     * Sets an answer for the suspendable function by wrapping a non-suspendable Mockito Answer.
+     *
+     * Alias for [thenAnswer].
+     */
+    infix fun doAnswer(answer: Answer<*>): CoroutinesOngoingStubbing<T> {
+        return thenAnswer(answer)
+    }
+
+    /**
+     * Sets an answer for the suspendable function by wrapping a non-suspendable Mockito Answer.
+     */
+    infix fun thenAnswer(answer: Answer<*>): CoroutinesOngoingStubbing<T> {
+        return if (mockitoOngoingStubbing.lastInvocationMethodIsSuspend ?: false) {
+            answer.wrapAsSuspendableAnswer()
+        } else {
+            answer // to support stubbing a sync method call while using wheneverBlocking()/onBlocking()
+        }.let {
+            CoroutinesOngoingStubbing(mockitoOngoingStubbing.thenAnswer(it))
+        }
+    }
+
+    private fun Answer<*>.wrapAsSuspendableAnswer(): Answer<out Any?> =
+        (this as? SuspendableAnswer<*>) ?: SuspendableAnswer(
+            { invocation ->
+                suspendToEnforceProperValueBoxing()
+                this.answer(invocation)
+            }
+        )
+
+    private suspend fun suspendToEnforceProperValueBoxing() {
+        // delaying for 1 ms, forces a suspension to happen.
+        // This (somehow) ensures that value class instances will be properly boxed when the
+        // answer is yielded by the mock
+        delay(1)
+    }
+
+    /**
+     * Sets consecutive return values to be returned when the method is called.
+     *
+     * Alias for [OngoingStubbing.thenReturn].
+     */
+    fun doReturn(t: T, vararg ts: T): CoroutinesOngoingStubbing<T> {
+        return thenReturn(listOf(t, *ts))
+    }
+
+    /**
+     * Sets consecutive return values to be returned when the method is called.
+     */
+    fun doReturnConsecutively(vararg ts: T): CoroutinesOngoingStubbing<T> {
+        return doReturnConsecutively(listOf(*ts))
+    }
+
+    /**
+     * Sets consecutive return values to be returned when the method is called.
+     */
+    infix fun doReturnConsecutively(ts: List<T>): CoroutinesOngoingStubbing<T> {
+        return thenReturn(ts)
+    }
+
+    /**
+     * Sets Throwable objects to be thrown when the method is called.
+     *
+     * Alias for [OngoingStubbing.thenThrow].
+     */
+    infix fun doThrow(t: Throwable): CoroutinesOngoingStubbing<T> {
+        return CoroutinesOngoingStubbing(
+            mockitoOngoingStubbing.thenThrow(t)
+        )
+    }
+
+    /**
+     * Sets Throwable objects to be thrown when the method is called.
+     *
+     * Alias for [OngoingStubbing.doThrow].
+     */
+    fun doThrow(
+        t: Throwable,
+        vararg ts: Throwable
+    ): CoroutinesOngoingStubbing<T> {
+        return CoroutinesOngoingStubbing(
+            mockitoOngoingStubbing.thenThrow(t, *ts)
+        )
+    }
+
+    /**
+     * Sets a Throwable type to be thrown when the method is called.
+     */
+    infix fun doThrow(t: KClass<out Throwable>): CoroutinesOngoingStubbing<T> {
+        return CoroutinesOngoingStubbing(
+            mockitoOngoingStubbing.thenThrow(t.java)
+        )
+    }
+
+    /**
+     * Sets Throwable classes to be thrown when the method is called.
+     */
+    fun doThrow(
+        t: KClass<out Throwable>,
+        vararg ts: KClass<out Throwable>
+    ): CoroutinesOngoingStubbing<T> {
+        return CoroutinesOngoingStubbing(
+            mockitoOngoingStubbing.thenThrow(
+                t.java,
+                *ts.map { it.java }.toTypedArray()
+            )
+        )
+    }
+
+    private fun thenReturn(values: List<T>): CoroutinesOngoingStubbing<T> {
+        return thenAnswer(
+            values.map { value ->
+                SuspendableAnswer(
+                    {
+                        suspendToEnforceProperValueBoxing()
+                        value
+                    }
+                )
+            }
+        )
+    }
+
+    private fun thenAnswer(answers: List<SuspendableAnswer<T>>): CoroutinesOngoingStubbing<T> {
+        return CoroutinesOngoingStubbing(
+            answers
+                .fold(mockitoOngoingStubbing) { stubbing, answer -> stubbing.thenAnswer(answer) }
+        )
+    }
+}
diff --git a/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/KInvocationOnMock.kt b/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/KInvocationOnMock.kt
index b433b761..66f13d64 100644
--- a/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/KInvocationOnMock.kt
+++ b/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/KInvocationOnMock.kt
@@ -28,7 +28,7 @@ package org.mockito.kotlin
 import org.mockito.invocation.InvocationOnMock
 
 class KInvocationOnMock(
-    private val invocationOnMock: InvocationOnMock
+    val invocationOnMock: InvocationOnMock
 ) : InvocationOnMock by invocationOnMock {
 
     operator fun <T> component1(): T = invocationOnMock.getArgument(0)
@@ -36,4 +36,58 @@ class KInvocationOnMock(
     operator fun <T> component3(): T = invocationOnMock.getArgument(2)
     operator fun <T> component4(): T = invocationOnMock.getArgument(3)
     operator fun <T> component5(): T = invocationOnMock.getArgument(4)
+
+    /**
+     * The first argument.
+     * @throws IndexOutOfBoundsException if the argument is not available.
+     */
+    inline fun <reified T> first(): T = invocationOnMock.getArgument(0)
+
+    /**
+     * The second argument.
+     * @throws IndexOutOfBoundsException if the argument is not available.
+     */
+    inline fun <reified T> second(): T = invocationOnMock.getArgument(1)
+
+    /**
+     * The third argument.
+     * @throws IndexOutOfBoundsException if the argument is not available.
+     */
+    inline fun <reified T> third(): T = invocationOnMock.getArgument(2)
+
+    /**
+     * The fourth argument.
+     * @throws IndexOutOfBoundsException if the argument is not available.
+     */
+    inline fun <reified T> fourth(): T = invocationOnMock.getArgument(3)
+
+    /**
+     * The fifth argument.
+     * @throws IndexOutOfBoundsException if the argument is not available.
+     */
+    inline fun <reified T> fifth(): T = invocationOnMock.getArgument(4)
+
+    /**
+     * The last argument.
+     * @throws IndexOutOfBoundsException if the argument is not available.
+     */
+    inline fun <reified T> last(): T {
+        val lastIndex  = invocationOnMock.arguments.size - 1
+        return invocationOnMock.getArgument(lastIndex)
+    }
+
+    /**
+     * The single argument.
+     * @throws IndexOutOfBoundsException if the argument is not available.
+     */
+    inline fun <reified T> single(): T {
+        val size  = invocationOnMock.arguments.size
+        require(size == 1) { "The invocation was expected to have exactly 1 argument but got $size." }
+        return first()
+    }
+
+    /**
+     * The all arguments.
+     */
+    fun all(): List<Any> = invocationOnMock.arguments.toList()
 }
diff --git a/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/KStubbing.kt b/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/KStubbing.kt
index 31a7c75c..4e20e56c 100644
--- a/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/KStubbing.kt
+++ b/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/KStubbing.kt
@@ -25,21 +25,25 @@
 
 package org.mockito.kotlin
 
-import org.mockito.kotlin.internal.createInstance
 import kotlinx.coroutines.runBlocking
 import org.mockito.Mockito
 import org.mockito.exceptions.misusing.NotAMockException
+import org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress
+import org.mockito.kotlin.internal.createInstance
 import org.mockito.stubbing.OngoingStubbing
 import org.mockito.stubbing.Stubber
 import kotlin.reflect.KClass
 
-inline fun <T : Any> stubbing(
-    mock: T,
-    stubbing: KStubbing<T>.(T) -> Unit
-) {
+/**
+ * Apply stubbing on the given mock. The stubbed behavior of the mock can then be specified in a supplied lambda.
+ */
+inline fun <T : Any> stubbing(mock: T, stubbing: KStubbing<T>.(T) -> Unit) {
     KStubbing(mock).stubbing(mock)
 }
 
+/**
+ * Apply stubbing on the given mock. The stubbed behavior of the mock can then be specified in a supplied lambda.
+ */
 inline fun <T : Any> T.stub(stubbing: KStubbing<T>.(T) -> Unit): T {
     return apply { KStubbing(this).stubbing(this) }
 }
@@ -49,12 +53,59 @@ class KStubbing<out T : Any>(val mock: T) {
         if (!mockingDetails(mock).isMock) throw NotAMockException("Stubbing target is not a mock!")
     }
 
-    fun <R> on(methodCall: R): OngoingStubbing<R> = Mockito.`when`(methodCall)
+    /**
+     * Enables stubbing methods. Use it when you want the mock to return particular value when particular method is called.
+     *
+     * Simply put: `When the x method is called then return y`
+     */
+    fun <R> on(methodCall: R): OngoingStubbing<R> = mockitoWhen(methodCall)
+
+    /**
+     * Enables stubbing methods. Use it when you want the mock to return particular value when particular method is called.
+     *
+     * Simply put: `When the x method is called then return y`
+     */
+    fun <R> on(methodCall: T.() -> R): OngoingStubbing<R> {
+        return try {
+            mockitoWhen(mock.methodCall())
+        } catch (e: NullPointerException) {
+            throw MockitoKotlinException(
+                  "NullPointerException thrown when stubbing.\nThis may be due to two reasons:\n\t- The method you're trying to stub threw an NPE: look at the stack trace below;\n\t- You're trying to stub a generic method: try `onGeneric` instead.",
+                  e
+            )
+        }
+    }
+
+    /**
+     * Enables stubbing suspend functions. Use it when you want the mock to return particular value when particular suspend function is called.
+     *
+     * Simply put: `When the x suspend function is called then return y`
+     */
+    fun <R> onBlocking(suspendFunctionCall: suspend T.() -> R): CoroutinesOngoingStubbing<R> {
+        return CoroutinesOngoingStubbing(
+            runBlocking { mockitoWhen(mock.suspendFunctionCall()) }
+        )
+    }
+
+    /**
+     * Enables stubbing generic methods with return type [R]. Use it when you want the mock to return particular value when particular method is called.
+     *
+     * Simply put: `When the x method is called then return y of type R`
+     */
+    inline fun <reified R : Any> onGeneric(noinline methodCall: T.() -> R?): OngoingStubbing<R?> {
+        return onGeneric(methodCall, R::class)
+    }
 
-    fun <R : Any> onGeneric(methodCall: T.() -> R?, c: KClass<R>): OngoingStubbing<R> {
+
+    /**
+     * Enables stubbing generic methods with return type [R]. Use it when you want the mock to return particular value when particular method is called.
+     *
+     * Simply put: `When the x method is called then return y of type R`
+     */
+    fun <R : Any> onGeneric(methodCall: T.() -> R?, c: KClass<R>): OngoingStubbing<R?> {
         val r = try {
             mock.methodCall()
-        } catch (e: NullPointerException) {
+        } catch (_: NullPointerException) {
             // An NPE may be thrown by the Kotlin type system when the MockMethodInterceptor returns a
             // null value for a non-nullable generic type.
             // We catch this NPE to return a valid instance.
@@ -62,31 +113,27 @@ class KStubbing<out T : Any>(val mock: T) {
             // the wanted changes.
             createInstance(c)
         }
-        return Mockito.`when`(r)
+        return mockitoWhen(r)
     }
 
-    inline fun <reified R : Any> onGeneric(noinline methodCall: T.() -> R?): OngoingStubbing<R> {
-        return onGeneric(methodCall, R::class)
+    /**
+     * Completes stubbing a method, by addressing the method call to apply a given stubbed [org.mockito.stubbing.Answer] on.
+     * Use it when you want the mock to return particular value when particular method is called.
+     *
+     * Simply put: `Return y when the x method is called`
+     */
+    fun Stubber.on(methodCall: T.() -> Unit) {
+        this.`when`(mock).methodCall()
     }
 
-    fun <R> on(methodCall: T.() -> R): OngoingStubbing<R> {
-        return try {
-            Mockito.`when`(mock.methodCall())
-        } catch (e: NullPointerException) {
-            throw MockitoKotlinException(
-                  "NullPointerException thrown when stubbing.\nThis may be due to two reasons:\n\t- The method you're trying to stub threw an NPE: look at the stack trace below;\n\t- You're trying to stub a generic method: try `onGeneric` instead.",
-                  e
-            )
-        }
-    }
+    private fun <R> mockitoWhen(methodCall: R): OngoingStubbing<R> {
+        val ongoingStubbing = Mockito.`when`(methodCall)
 
-    fun <T : Any, R> KStubbing<T>.onBlocking(
-        m: suspend T.() -> R
-    ): OngoingStubbing<R> {
-        return runBlocking { Mockito.`when`(mock.m()) }
-    }
+        if (ongoingStubbing.getMock<T>() != mock) {
+            mockingProgress().reset()
+            throw IllegalArgumentException("Stubbing of another mock is not allowed")
+        }
 
-    fun Stubber.on(methodCall: T.() -> Unit) {
-        this.`when`(mock).methodCall()
+        return ongoingStubbing
     }
 }
diff --git a/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/OngoingStubbing.kt b/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/OngoingStubbing.kt
index 39c6dcb2..bd647263 100644
--- a/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/OngoingStubbing.kt
+++ b/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/OngoingStubbing.kt
@@ -25,35 +25,12 @@
 
 package org.mockito.kotlin
 
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.runBlocking
-import org.mockito.Mockito
 import org.mockito.kotlin.internal.KAnswer
 import org.mockito.kotlin.internal.SuspendableAnswer
 import org.mockito.stubbing.Answer
 import org.mockito.stubbing.OngoingStubbing
 import kotlin.reflect.KClass
 
-/**
- * Enables stubbing methods. Use it when you want the mock to return particular value when particular method is called.
- *
- * Alias for [Mockito.when].
- */
-@Suppress("NOTHING_TO_INLINE")
-inline fun <T> whenever(methodCall: T): OngoingStubbing<T> {
-    return Mockito.`when`(methodCall)!!
-}
-
-/**
- * Enables stubbing suspending methods. Use it when you want the mock to return particular value when particular suspending method is called.
- *
- * Warning: Only one method call can be stubbed in the function.
- * other method calls are ignored!
- */
-fun <T> wheneverBlocking(methodCall: suspend CoroutineScope.() -> T): OngoingStubbing<T> {
-    return runBlocking { Mockito.`when`(methodCall()) }
-}
-
 /**
  * Sets a return value to be returned when the method is called.
  *
@@ -72,6 +49,13 @@ fun <T> OngoingStubbing<T>.doReturn(t: T, vararg ts: T): OngoingStubbing<T> {
     return thenReturn(t, *ts)
 }
 
+/**
+ * Sets consecutive return values to be returned when the method is called.
+ */
+inline fun <reified T> OngoingStubbing<T>.doReturnConsecutively(vararg ts: T): OngoingStubbing<T> {
+    return doReturnConsecutively(listOf(*ts))
+}
+
 /**
  * Sets consecutive return values to be returned when the method is called.
  */
@@ -136,6 +120,15 @@ infix fun <T> OngoingStubbing<T>.doAnswer(answer: (KInvocationOnMock) -> T?): On
     return thenAnswer(KAnswer(answer))
 }
 
+/**
+ * Sets a generic Answer for a suspend function using a suspend lambda.
+ *
+ * Deprecated. Use wheneverBlocking() with doAnswer()/thenAnswer() instead.
+ */
+@Deprecated(
+    "Use wheneverBlocking() with doAnswer()/thenAnswer() instead.",
+    level = DeprecationLevel.WARNING
+)
 infix fun <T> OngoingStubbing<T>.doSuspendableAnswer(answer: suspend (KInvocationOnMock) -> T?): OngoingStubbing<T> {
     return thenAnswer(SuspendableAnswer(answer))
 }
diff --git a/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/Stubber.kt b/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/Stubber.kt
index 9b521de4..315845d5 100644
--- a/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/Stubber.kt
+++ b/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/Stubber.kt
@@ -29,7 +29,6 @@ import kotlinx.coroutines.runBlocking
 import org.mockito.Mockito
 import org.mockito.invocation.InvocationOnMock
 import org.mockito.kotlin.internal.SuspendableAnswer
-import org.mockito.stubbing.OngoingStubbing
 import org.mockito.stubbing.Stubber
 import kotlin.reflect.KClass
 
@@ -68,10 +67,19 @@ fun doThrow(vararg toBeThrown: Throwable): Stubber {
     return Mockito.doThrow(*toBeThrown)!!
 }
 
-fun <T> Stubber.whenever(mock: T) = `when`(mock)
+fun <T> Stubber.whenever(mock: T): T = `when`(mock)
 
 /**
- * Alias for when with suspending function
+ * Reverse stubber for suspending functions.
+ *
+ * Warning: Only one method call can be stubbed in the function.
+ * Subsequent method calls are ignored!
+ */
+fun <T> Stubber.onBlocking(mock: T, f: suspend T.() -> Unit) =
+    wheneverBlocking(mock, f)
+
+/**
+ * Reverse stubber for suspending functions.
  *
  * Warning: Only one method call can be stubbed in the function.
  * Subsequent method calls are ignored!
diff --git a/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/Whenever.kt b/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/Whenever.kt
new file mode 100644
index 00000000..657a95f4
--- /dev/null
+++ b/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/Whenever.kt
@@ -0,0 +1,70 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2018 Niek Haarman
+ * Copyright (c) 2007 Mockito contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package org.mockito.kotlin
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.runBlocking
+import org.mockito.Mockito
+import org.mockito.kotlin.internal.assertStubbingForNonSuspendableFunctionCall
+import org.mockito.kotlin.internal.assertStubbingForSuspendableFunctionCall
+import org.mockito.stubbing.OngoingStubbing
+
+/**
+ * Enables stubbing methods. Use it when you want the mock to return particular value when particular method is called.
+ *
+ * Alias for [org.mockito.Mockito.when].
+ */
+fun <T> whenever(methodCall: () -> T): OngoingStubbing<T> {
+    return whenever(methodCall())
+}
+
+/**
+ * Enables stubbing methods. Use it when you want the mock to return particular value when particular method is called.
+ *
+ * Alias for [org.mockito.Mockito.when].
+ */
+fun <T> whenever(methodCall: T): OngoingStubbing<T> {
+    val ongoingStubbing: OngoingStubbing<T> = Mockito.`when`(methodCall)
+    assertStubbingForNonSuspendableFunctionCall(ongoingStubbing)
+    return ongoingStubbing
+}
+
+/**
+ * Enables stubbing suspending methods. Use it when you want the mock to return particular value when particular suspending method is called.
+ *
+ * Warning: Only one method call can be stubbed in the function.
+ * other method calls are ignored!
+ */
+fun <T> wheneverBlocking(methodCall: suspend CoroutineScope.() -> T): CoroutinesOngoingStubbing<T> {
+    return CoroutinesOngoingStubbing(
+        runBlocking {
+            val ongoingStubbing: OngoingStubbing<T> = Mockito.`when`(methodCall())!!
+            assertStubbingForSuspendableFunctionCall(ongoingStubbing)
+            ongoingStubbing
+        }
+    )
+}
+
diff --git a/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/internal/KAnswer.kt b/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/internal/KAnswer.kt
index ca62f048..a06728bf 100644
--- a/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/internal/KAnswer.kt
+++ b/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/internal/KAnswer.kt
@@ -34,9 +34,9 @@ import org.mockito.stubbing.Answer
  */
 @Suppress("UNCHECKED_CAST")
 internal class KAnswer<T>(
-    private val body: (KInvocationOnMock) -> T?
+    private val block: (KInvocationOnMock) -> T?
 ) : Answer<T> {
     override fun answer(invocation: InvocationOnMock): T {
-        return body(KInvocationOnMock(invocation)) as T
+        return block.invoke(KInvocationOnMock(invocation)) as T
     }
 }
diff --git a/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/internal/OngoingStubbingUtil.kt b/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/internal/OngoingStubbingUtil.kt
new file mode 100644
index 00000000..2dc2ae64
--- /dev/null
+++ b/mockito-kotlin/src/main/kotlin/org/mockito/kotlin/internal/OngoingStubbingUtil.kt
@@ -0,0 +1,80 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2018 Niek Haarman
+ * Copyright (c) 2007 Mockito contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package org.mockito.kotlin.internal
+
+import org.mockito.internal.configuration.plugins.Plugins
+import org.mockito.internal.stubbing.OngoingStubbingImpl
+import org.mockito.stubbing.OngoingStubbing
+import java.lang.reflect.Method
+import kotlin.reflect.jvm.kotlinFunction
+
+
+fun <T> assertStubbingForNonSuspendableFunctionCall(ongoingStubbing: OngoingStubbing<T>) {
+    val method = ongoingStubbing.lastInvocationMethod ?: return
+    val isSuspend = method.kotlinFunction?.isSuspend ?: false
+
+    if (isSuspend) {
+        Plugins
+            .getMockitoLogger()
+            .warn(
+                "For stubbing suspendable function '${method.declaringClass.simpleName}" +
+                      ".${method.name}' better use 'wheneverBlocking()' instead, to get full " +
+                      "support for stubbing suspend functions."
+            )
+    }
+}
+
+fun <T> assertStubbingForSuspendableFunctionCall(ongoingStubbing: OngoingStubbing<T>) {
+    val method = ongoingStubbing.lastInvocationMethod ?: return
+    val isSuspend = method.kotlinFunction?.isSuspend ?: false
+
+    if (!isSuspend) {
+        warn(
+            "For stubbing non-suspendable function '${method.declaringClass.simpleName}" +
+                  ".${method.name}' better use 'whenever()' instead."
+        )
+    }
+}
+
+private fun warn(message: String) {
+    Plugins.getMockitoLogger().warn(message)
+}
+
+val <T> OngoingStubbing<T>.lastInvocationMethodIsSuspend: Boolean?
+    get() {
+        val method = this.lastInvocationMethod
+        if (method == null) {
+            warn("Failed to determine last invocation on a mock.")
+        }
+        return method?.kotlinFunction?.isSuspend
+    }
+
+private val <T> OngoingStubbing<T>.lastInvocationMethod: Method?
+    get(): Method? =
+        (this as? OngoingStubbingImpl<T>)
+            ?.registeredInvocations
+            ?.lastOrNull()
+            ?.method
diff --git a/mockito-kotlin/src/test/kotlin/test/CoroutinesTest.kt b/mockito-kotlin/src/test/kotlin/test/CoroutinesTest.kt
deleted file mode 100644
index fa5b9178..00000000
--- a/mockito-kotlin/src/test/kotlin/test/CoroutinesTest.kt
+++ /dev/null
@@ -1,537 +0,0 @@
-@file:Suppress("EXPERIMENTAL_FEATURE_WARNING")
-
-package test
-
-import com.nhaarman.expect.expect
-import kotlinx.coroutines.*
-import kotlinx.coroutines.channels.actor
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertThrows
-import org.junit.Test
-import org.mockito.InOrder
-import org.mockito.kotlin.*
-import java.util.*
-
-class CoroutinesTest {
-
-    @Test
-    fun stubbingSuspending() {
-        /* Given */
-        val m = mock<SomeInterface> {
-            onBlocking { suspending() } doReturn 42
-        }
-
-        /* When */
-        val result = runBlocking { m.suspending() }
-
-        /* Then */
-        expect(result).toBe(42)
-    }
-
-    @Test
-    fun stubbingSuspending_usingSuspendingFunction() {
-        /* Given */
-        val m = mock<SomeInterface> {
-            onBlocking { suspending() } doReturn runBlocking { SomeClass().result(42) }
-        }
-
-        /* When */
-        val result = runBlocking { m.suspending() }
-
-        /* Then */
-        expect(result).toBe(42)
-    }
-
-    @Test
-    fun stubbingSuspending_runBlocking() = runBlocking {
-        /* Given */
-        val m = mock<SomeInterface> {
-            onBlocking { suspending() } doReturn 42
-        }
-
-        /* When */
-        val result = m.suspending()
-
-        /* Then */
-        expect(result).toBe(42)
-    }
-
-    @Test
-    fun stubbingSuspending_wheneverBlocking() {
-        /* Given */
-        val m: SomeInterface = mock()
-        wheneverBlocking { m.suspending() }
-            .doReturn(42)
-
-        /* When */
-        val result = runBlocking { m.suspending() }
-
-        /* Then */
-        expect(result).toBe(42)
-    }
-
-    @Test
-    fun stubbingSuspending_doReturn() {
-        /* Given */
-        val m = spy(SomeClass())
-        doReturn(10)
-            .wheneverBlocking(m) {
-                delaying()
-            }
-
-        /* When */
-        val result = runBlocking { m.delaying() }
-
-        /* Then */
-        expect(result).toBe(10)
-    }
-
-    @Test
-    fun stubbingNonSuspending() {
-        /* Given */
-        val m = mock<SomeInterface> {
-            onBlocking { nonsuspending() } doReturn 42
-        }
-
-        /* When */
-        val result = m.nonsuspending()
-
-        /* Then */
-        expect(result).toBe(42)
-    }
-
-    @Test
-    fun stubbingNonSuspending_runBlocking() = runBlocking {
-        /* Given */
-        val m = mock<SomeInterface> {
-            onBlocking { nonsuspending() } doReturn 42
-        }
-
-        /* When */
-        val result = m.nonsuspending()
-
-        /* Then */
-        expect(result).toBe(42)
-    }
-
-    @Test
-    fun delayingResult() {
-        /* Given */
-        val m = SomeClass()
-
-        /* When */
-        val result = runBlocking { m.delaying() }
-
-        /* Then */
-        expect(result).toBe(42)
-    }
-
-    @Test
-    fun delayingResult_runBlocking() = runBlocking {
-        /* Given */
-        val m = SomeClass()
-
-        /* When */
-        val result = m.delaying()
-
-        /* Then */
-        expect(result).toBe(42)
-    }
-
-    @Test
-    fun verifySuspendFunctionCalled() {
-        /* Given */
-        val m = mock<SomeInterface>()
-
-        /* When */
-        runBlocking { m.suspending() }
-
-        /* Then */
-        runBlocking { verify(m).suspending() }
-    }
-
-    @Test
-    fun verifySuspendFunctionCalled_runBlocking() = runBlocking<Unit> {
-        val m = mock<SomeInterface>()
-
-        m.suspending()
-
-        verify(m).suspending()
-    }
-
-    @Test
-    fun verifySuspendFunctionCalled_verifyBlocking() {
-        val m = mock<SomeInterface>()
-
-        runBlocking { m.suspending() }
-
-        verifyBlocking(m) { suspending() }
-    }
-
-    @Test
-    fun verifyAtLeastOnceSuspendFunctionCalled_verifyBlocking() {
-        val m = mock<SomeInterface>()
-
-        runBlocking { m.suspending() }
-        runBlocking { m.suspending() }
-
-        verifyBlocking(m, atLeastOnce()) { suspending() }
-    }
-
-    @Test
-    fun verifySuspendMethod() = runBlocking {
-        val testSubject: SomeInterface = mock()
-
-        testSubject.suspending()
-
-        inOrder(testSubject) {
-            verify(testSubject).suspending()
-        }
-    }
-
-    @Test
-    fun answerWithSuspendFunction() = runBlocking {
-        val fixture: SomeInterface = mock()
-
-        whenever(fixture.suspendingWithArg(any())).doSuspendableAnswer {
-            withContext(Dispatchers.Default) { it.getArgument<Int>(0) }
-        }
-
-        assertEquals(5, fixture.suspendingWithArg(5))
-    }
-
-    @Test
-    fun inplaceAnswerWithSuspendFunction() = runBlocking {
-        val fixture: SomeInterface = mock {
-            onBlocking { suspendingWithArg(any()) } doSuspendableAnswer {
-                withContext(Dispatchers.Default) { it.getArgument<Int>(0) }
-            }
-        }
-
-        assertEquals(5, fixture.suspendingWithArg(5))
-    }
-
-    @Test
-    fun callFromSuspendFunction() = runBlocking {
-        val fixture: SomeInterface = mock()
-
-        whenever(fixture.suspendingWithArg(any())).doSuspendableAnswer {
-            withContext(Dispatchers.Default) { it.getArgument<Int>(0) }
-        }
-
-        val result = async {
-            val answer = fixture.suspendingWithArg(5)
-
-            Result.success(answer)
-        }
-
-        assertEquals(5, result.await().getOrThrow())
-    }
-
-    @Test
-    @OptIn(ObsoleteCoroutinesApi::class)
-    fun callFromActor() = runBlocking {
-        val fixture: SomeInterface = mock()
-
-        whenever(fixture.suspendingWithArg(any())).doSuspendableAnswer {
-            withContext(Dispatchers.Default) { it.getArgument<Int>(0) }
-        }
-
-        val actor = actor<Optional<Int>> {
-            for (element in channel) {
-                fixture.suspendingWithArg(element.get())
-            }
-        }
-
-        actor.send(Optional.of(10))
-        actor.close()
-
-        verify(fixture).suspendingWithArg(10)
-
-        Unit
-    }
-
-    @Test
-    fun answerWithSuspendFunctionWithoutArgs() = runBlocking {
-        val fixture: SomeInterface = mock()
-
-        whenever(fixture.suspending()).doSuspendableAnswer {
-            withContext(Dispatchers.Default) { 42 }
-        }
-
-        assertEquals(42, fixture.suspending())
-    }
-
-    @Test
-    fun answerWithSuspendFunctionWithDestructuredArgs() = runBlocking {
-        val fixture: SomeInterface = mock()
-
-        whenever(fixture.suspendingWithArg(any())).doSuspendableAnswer { (i: Int) ->
-            withContext(Dispatchers.Default) { i }
-        }
-
-        assertEquals(5, fixture.suspendingWithArg(5))
-    }
-
-    @Test
-    fun willAnswerWithControlledSuspend() = runBlocking {
-        val fixture: SomeInterface = mock()
-
-        val job = Job()
-
-        whenever(fixture.suspending()).doSuspendableAnswer {
-            job.join()
-            5
-        }
-
-        val asyncTask = async {
-            fixture.suspending()
-        }
-
-        job.complete()
-
-        withTimeout(100) {
-            assertEquals(5, asyncTask.await())
-        }
-    }
-
-    @Test
-    fun stubberAnswerWithSuspendFunction() = runBlocking {
-        val fixture: SomeInterface = mock()
-
-        doSuspendableAnswer {
-            withContext(Dispatchers.Default) { it.getArgument<Int>(0) }
-        }.whenever(fixture).suspendingWithArg(any())
-
-        assertEquals(5, fixture.suspendingWithArg(5))
-    }
-
-    @Test
-    fun stubberCallFromSuspendFunction() = runBlocking {
-        val fixture: SomeInterface = mock()
-
-        doSuspendableAnswer {
-            withContext(Dispatchers.Default) { it.getArgument<Int>(0) }
-        }.whenever(fixture).suspendingWithArg(any())
-
-        val result = async {
-            val answer = fixture.suspendingWithArg(5)
-
-            Result.success(answer)
-        }
-
-        assertEquals(5, result.await().getOrThrow())
-    }
-
-    @Test
-    @OptIn(ObsoleteCoroutinesApi::class)
-    fun stubberCallFromActor() = runBlocking {
-        val fixture: SomeInterface = mock()
-
-        doSuspendableAnswer {
-            withContext(Dispatchers.Default) { it.getArgument<Int>(0) }
-        }.whenever(fixture).suspendingWithArg(any())
-
-        val actor = actor<Optional<Int>> {
-            for (element in channel) {
-                fixture.suspendingWithArg(element.get())
-            }
-        }
-
-        actor.send(Optional.of(10))
-        actor.close()
-
-        verify(fixture).suspendingWithArg(10)
-
-        Unit
-    }
-
-    @Test
-    fun stubberAnswerWithSuspendFunctionWithoutArgs() = runBlocking {
-        val fixture: SomeInterface = mock()
-
-        doSuspendableAnswer {
-            withContext(Dispatchers.Default) { 42 }
-        }.whenever(fixture).suspending()
-
-        assertEquals(42, fixture.suspending())
-    }
-
-    @Test
-    fun stubberAnswerWithSuspendFunctionWithDestructuredArgs() = runBlocking {
-        val fixture: SomeInterface = mock()
-
-        doSuspendableAnswer { (i: Int) ->
-            withContext(Dispatchers.Default) { i }
-        }.whenever(fixture).suspendingWithArg(any())
-
-        assertEquals(5, fixture.suspendingWithArg(5))
-    }
-
-    @Test
-    fun stubberWillAnswerWithControlledSuspend() = runBlocking {
-        val fixture: SomeInterface = mock()
-
-        val job = Job()
-
-        doSuspendableAnswer {
-            job.join()
-            5
-        }.whenever(fixture).suspending()
-
-        val asyncTask = async {
-            fixture.suspending()
-        }
-
-        job.complete()
-
-        withTimeout(100) {
-            assertEquals(5, asyncTask.await())
-        }
-    }
-
-    @Test
-    fun inOrderRemainsCompatible() {
-        /* Given */
-        val fixture: SomeInterface = mock()
-
-        /* When */
-        val inOrder = inOrder(fixture)
-
-        /* Then */
-        expect(inOrder).toBeInstanceOf<InOrder>()
-    }
-
-    @Test
-    fun inOrderSuspendingCalls() {
-        /* Given */
-        val fixtureOne: SomeInterface = mock()
-        val fixtureTwo: SomeInterface = mock()
-
-        /* When */
-        runBlocking {
-            fixtureOne.suspending()
-            fixtureTwo.suspending()
-        }
-
-        /* Then */
-        val inOrder = inOrder(fixtureOne, fixtureTwo)
-        inOrder.verifyBlocking(fixtureOne) { suspending() }
-        inOrder.verifyBlocking(fixtureTwo) { suspending() }
-    }
-
-    @Test
-    fun inOrderSuspendingCallsFailure() {
-        /* Given */
-        val fixtureOne: SomeInterface = mock()
-        val fixtureTwo: SomeInterface = mock()
-
-        /* When */
-        runBlocking {
-            fixtureOne.suspending()
-            fixtureTwo.suspending()
-        }
-
-        /* Then */
-        val inOrder = inOrder(fixtureOne, fixtureTwo)
-        inOrder.verifyBlocking(fixtureTwo) { suspending() }
-        assertThrows(AssertionError::class.java) {
-            inOrder.verifyBlocking(fixtureOne) { suspending() }
-        }
-    }
-
-    @Test
-    fun inOrderBlockSuspendingCalls() {
-        /* Given */
-        val fixtureOne: SomeInterface = mock()
-        val fixtureTwo: SomeInterface = mock()
-
-        /* When */
-        runBlocking {
-            fixtureOne.suspending()
-            fixtureTwo.suspending()
-        }
-
-        /* Then */
-        inOrder(fixtureOne, fixtureTwo) {
-            verifyBlocking(fixtureOne) { suspending() }
-            verifyBlocking(fixtureTwo) { suspending() }
-        }
-    }
-
-    @Test
-    fun inOrderBlockSuspendingCallsFailure() {
-        /* Given */
-        val fixtureOne: SomeInterface = mock()
-        val fixtureTwo: SomeInterface = mock()
-
-        /* When */
-        runBlocking {
-            fixtureOne.suspending()
-            fixtureTwo.suspending()
-        }
-
-        /* Then */
-        inOrder(fixtureOne, fixtureTwo) {
-            verifyBlocking(fixtureTwo) { suspending() }
-            assertThrows(AssertionError::class.java) {
-                verifyBlocking(fixtureOne) { suspending() }
-            }
-        }
-    }
-
-    @Test
-    fun inOrderOnObjectSuspendingCalls() {
-        /* Given */
-        val fixture: SomeInterface = mock()
-
-        /* When */
-        runBlocking {
-            fixture.suspendingWithArg(1)
-            fixture.suspendingWithArg(2)
-        }
-
-        /* Then */
-        fixture.inOrder {
-            verifyBlocking { suspendingWithArg(1) }
-            verifyBlocking { suspendingWithArg(2) }
-        }
-    }
-
-    @Test
-    fun inOrderOnObjectSuspendingCallsFailure() {
-        /* Given */
-        val fixture: SomeInterface = mock()
-
-        /* When */
-        runBlocking {
-            fixture.suspendingWithArg(1)
-            fixture.suspendingWithArg(2)
-        }
-
-        /* Then */
-        fixture.inOrder {
-            verifyBlocking { suspendingWithArg(2) }
-            assertThrows(AssertionError::class.java) {
-                verifyBlocking { suspendingWithArg(1) }
-            }
-        }
-    }
-}
-
-interface SomeInterface {
-
-    suspend fun suspending(): Int
-    suspend fun suspendingWithArg(arg: Int): Int
-    fun nonsuspending(): Int
-}
-
-open class SomeClass {
-
-    suspend fun result(r: Int) = withContext(Dispatchers.Default) { r }
-
-    open suspend fun delaying() = withContext(Dispatchers.Default) {
-        delay(100)
-        42
-    }
-}
diff --git a/tests/build.gradle b/tests/build.gradle
index dd447d93..6bb524c8 100644
--- a/tests/build.gradle
+++ b/tests/build.gradle
@@ -19,7 +19,7 @@ dependencies {
 
     testImplementation 'junit:junit:4.13.2'
     testImplementation "com.nhaarman:expect.kt:1.0.1"
-    testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:1.9.0-RC"
+    testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:1.10.2"
 }
 
 tasks.withType(KotlinCompile).configureEach {
diff --git a/tests/src/test/kotlin/org/mockito/kotlin/internal/KAnswerTest.kt b/tests/src/test/kotlin/org/mockito/kotlin/internal/KAnswerTest.kt
new file mode 100644
index 00000000..5fc20e3d
--- /dev/null
+++ b/tests/src/test/kotlin/org/mockito/kotlin/internal/KAnswerTest.kt
@@ -0,0 +1,141 @@
+package org.mockito.kotlin.internal
+
+import com.nhaarman.expect.expect
+import org.junit.Test
+import org.mockito.kotlin.anyVararg
+import org.mockito.kotlin.doAnswer
+import org.mockito.kotlin.mock
+import test.SynchronousFunctions
+import test.assertThrows
+
+class KAnswerTest {
+    @Test
+    fun `should answer with first invocation argument`() {
+        /* Given */
+        val mock = mock<SynchronousFunctions> {
+            on { varargStringResult(anyVararg()) } doAnswer { it.first() }
+        }
+
+        /* When */
+        val result = mock.varargStringResult("A", "B", "C", "D", "E")
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+
+    @Test
+    fun `should answer with second invocation argument`() {
+        /* Given */
+        val mock = mock<SynchronousFunctions> {
+            on { varargStringResult(anyVararg()) } doAnswer { it.second() }
+        }
+
+        /* When */
+        val result = mock.varargStringResult("A", "B", "C", "D", "E")
+
+        /* Then */
+        expect(result).toBe("B")
+    }
+
+    @Test
+    fun `should answer with third invocation argument`() {
+        /* Given */
+        val mock = mock<SynchronousFunctions> {
+            on { varargStringResult(anyVararg()) } doAnswer { it.third() }
+        }
+
+        /* When */
+        val result = mock.varargStringResult("A", "B", "C", "D", "E")
+
+        /* Then */
+        expect(result).toBe("C")
+    }
+
+    @Test
+    fun `should answer with fourth invocation argument`() {
+        /* Given */
+        val mock = mock<SynchronousFunctions> {
+            on { varargStringResult(anyVararg()) } doAnswer { it.fourth() }
+        }
+
+        /* When */
+        val result = mock.varargStringResult("A", "B", "C", "D", "E")
+
+        /* Then */
+        expect(result).toBe("D")
+    }
+
+    @Test
+    fun `should answer with fifth invocation argument`() {
+        /* Given */
+        val mock = mock<SynchronousFunctions> {
+            on { varargStringResult(anyVararg()) } doAnswer { it.fifth() }
+        }
+
+        /* When */
+        val result = mock.varargStringResult("A", "B", "C", "D", "E")
+
+        /* Then */
+        expect(result).toBe("E")
+    }
+
+    @Test
+    fun `should answer with last invocation argument`() {
+        /* Given */
+        val mock = mock<SynchronousFunctions> {
+            on { varargStringResult(anyVararg()) } doAnswer { it.last() }
+        }
+
+        /* When */
+        val result = mock.varargStringResult("A", "B", "C", "D", "E")
+
+        /* Then */
+        expect(result).toBe("E")
+    }
+
+    @Test
+    fun `should answer with all invocation arguments`() {
+        /* Given */
+        val mock = mock<SynchronousFunctions> {
+            on { varargStringResult(anyVararg()) } doAnswer {
+                it.all().joinToString("; ")
+            }
+        }
+
+        /* When */
+        val result = mock.varargStringResult("A", "B", "C", "D", "E")
+
+        /* Then */
+        expect(result).toBe("A; B; C; D; E")
+    }
+
+    @Test
+    fun `should answer with single invocation argument`() {
+        /* Given */
+        val mock = mock<SynchronousFunctions> {
+            on { varargStringResult(anyVararg()) } doAnswer { it.single() }
+        }
+
+        /* When */
+        val result = mock.varargStringResult("A")
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+
+    @Test
+    fun `should throw when trying to answer with single invocation argument, but with actually more`() {
+        /* Given */
+        val mock = mock<SynchronousFunctions> {
+            on { varargStringResult(anyVararg()) } doAnswer { it.single() }
+        }
+
+        /* When, Then */
+        val exception: IllegalArgumentException = assertThrows {
+            mock.varargStringResult("A", "B")
+        }
+
+        /* Then */
+        expect(exception.message).toContain("xpected to have exactly 1 argument but got 2")
+    }
+}
diff --git a/tests/src/test/kotlin/test/AdditionalMatchersTest.kt b/tests/src/test/kotlin/test/AdditionalMatchersTest.kt
index bb6f5ede..9e42ed64 100644
--- a/tests/src/test/kotlin/test/AdditionalMatchersTest.kt
+++ b/tests/src/test/kotlin/test/AdditionalMatchersTest.kt
@@ -7,7 +7,7 @@ class AdditionalCaptorsTest : TestBase() {
 
     @Test
     fun testGeq() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             int(1)
             verify(this).int(geq(0))
             verify(this).int(geq(1))
@@ -17,7 +17,7 @@ class AdditionalCaptorsTest : TestBase() {
 
     @Test
     fun testLeq() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             int(1)
             verify(this).int(leq(2))
             verify(this).int(leq(1))
@@ -27,7 +27,7 @@ class AdditionalCaptorsTest : TestBase() {
 
     @Test
     fun testGt() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             int(1)
             verify(this).int(gt(0))
             verify(this, never()).int(gt(1))
@@ -36,7 +36,7 @@ class AdditionalCaptorsTest : TestBase() {
 
     @Test
     fun testLt() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             int(1)
             verify(this).int(lt(2))
             verify(this, never()).int(lt(1))
@@ -45,7 +45,7 @@ class AdditionalCaptorsTest : TestBase() {
 
     @Test
     fun testCmpEq() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             int(1)
             verify(this).int(cmpEq(1))
             verify(this, never()).int(cmpEq(2))
@@ -54,7 +54,7 @@ class AdditionalCaptorsTest : TestBase() {
 
     @Test
     fun testAryEqBoolean() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             booleanArray(booleanArrayOf(true, false, true))
             verify(this).booleanArray(aryEq(booleanArrayOf(true, false, true)))
             verify(this, never()).booleanArray(aryEq(booleanArrayOf(true, false)))
@@ -63,7 +63,7 @@ class AdditionalCaptorsTest : TestBase() {
 
     @Test
     fun testAryEqByte() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             byteArray(byteArrayOf(1, 2, 3))
             verify(this).byteArray(aryEq(byteArrayOf(1, 2, 3)))
             verify(this, never()).byteArray(aryEq(byteArrayOf(1, 2)))
@@ -72,7 +72,7 @@ class AdditionalCaptorsTest : TestBase() {
 
     @Test
     fun testAryEqShort() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             shortArray(shortArrayOf(1, 2, 3))
             verify(this).shortArray(aryEq(shortArrayOf(1, 2, 3)))
             verify(this, never()).shortArray(aryEq(shortArrayOf(1, 2)))
@@ -81,7 +81,7 @@ class AdditionalCaptorsTest : TestBase() {
 
     @Test
     fun testAryEqInt() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             intArray(intArrayOf(1, 2, 3))
             verify(this).intArray(aryEq(intArrayOf(1, 2, 3)))
             verify(this, never()).intArray(aryEq(intArrayOf(1, 2)))
@@ -90,7 +90,7 @@ class AdditionalCaptorsTest : TestBase() {
 
     @Test
     fun testAryEqLong() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             longArray(longArrayOf(1, 2, 3))
             verify(this).longArray(aryEq(longArrayOf(1, 2, 3)))
             verify(this, never()).longArray(aryEq(longArrayOf(1, 2)))
@@ -99,7 +99,7 @@ class AdditionalCaptorsTest : TestBase() {
 
     @Test
     fun testAryEqChar() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             charArray(charArrayOf('1', '2', '3'))
             verify(this).charArray(aryEq(charArrayOf('1', '2', '3')))
             verify(this, never()).charArray(aryEq(charArrayOf('1', '2')))
@@ -108,7 +108,7 @@ class AdditionalCaptorsTest : TestBase() {
 
     @Test
     fun testAryEqFloat() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             floatArray(floatArrayOf(1f, 2f, 3.4f))
             verify(this).floatArray(aryEq(floatArrayOf(1f, 2f, 3.4f)))
             verify(this, never()).floatArray(aryEq(floatArrayOf(1f, 2f)))
@@ -117,7 +117,7 @@ class AdditionalCaptorsTest : TestBase() {
 
     @Test
     fun testAryEqDouble() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             doubleArray(doubleArrayOf(1.0, 2.0, 3.4))
             verify(this).doubleArray(aryEq(doubleArrayOf(1.0, 2.0, 3.4)))
             verify(this, never()).doubleArray(aryEq(doubleArrayOf(1.0, 2.0)))
@@ -126,7 +126,7 @@ class AdditionalCaptorsTest : TestBase() {
 
     @Test
     fun testAryEq() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             stringArray(arrayOf("Hello", "there"))
             verify(this).stringArray(aryEq(arrayOf("Hello", "there")))
             verify(this, never()).stringArray(aryEq(arrayOf("Hello")))
@@ -135,7 +135,7 @@ class AdditionalCaptorsTest : TestBase() {
 
     @Test
     fun testFind() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             string("Hello")
             verify(this).string(find("l+o$".toRegex()))
             verify(this, never()).string(find("l$".toRegex()))
@@ -144,7 +144,7 @@ class AdditionalCaptorsTest : TestBase() {
 
     @Test
     fun testAnd() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             int(5)
             verify(this).int(and(geq(4), leq(6)))
             verify(this, never()).int(and(geq(4), leq(4)))
@@ -153,7 +153,7 @@ class AdditionalCaptorsTest : TestBase() {
 
     @Test
     fun testOr() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             int(5)
             verify(this).int(and(gt(4), lt(6)))
             verify(this, never()).int(and(gt(4), lt(4)))
@@ -162,7 +162,7 @@ class AdditionalCaptorsTest : TestBase() {
 
     @Test
     fun testNot() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             int(5)
             verify(this).int(not(eq(4)))
             verify(this, never()).int(not(eq(5)))
diff --git a/tests/src/test/kotlin/test/ArgumentCaptorTest.kt b/tests/src/test/kotlin/test/ArgumentCaptorTest.kt
index 14382a5c..891f7ff5 100644
--- a/tests/src/test/kotlin/test/ArgumentCaptorTest.kt
+++ b/tests/src/test/kotlin/test/ArgumentCaptorTest.kt
@@ -101,7 +101,7 @@ class ArgumentCaptorTest : TestBase() {
     @Test
     fun argumentCaptor_withNullValue_usingNonNullable() {
         /* Given */
-        val m: Methods = mock()
+        val m: SynchronousFunctions = mock()
 
         /* When */
         m.nullableString(null)
@@ -115,7 +115,7 @@ class ArgumentCaptorTest : TestBase() {
     @Test
     fun argumentCaptor_withNullValue_usingNullable() {
         /* Given */
-        val m: Methods = mock()
+        val m: SynchronousFunctions = mock()
 
         /* When */
         m.nullableString(null)
@@ -173,7 +173,7 @@ class ArgumentCaptorTest : TestBase() {
     @Test
     fun argumentCaptor_multipleValuesIncludingNull() {
         /* Given */
-        val m: Methods = mock()
+        val m: SynchronousFunctions = mock()
 
         /* When */
         m.nullableString("test")
@@ -188,7 +188,7 @@ class ArgumentCaptorTest : TestBase() {
     @Test
     fun argumentCaptor_callProperties() {
         /* Given */
-        val m: Methods = mock()
+        val m: SynchronousFunctions = mock()
 
         /* When */
         m.int(1)
@@ -211,7 +211,7 @@ class ArgumentCaptorTest : TestBase() {
     @Test(expected = IndexOutOfBoundsException::class)
     fun argumentCaptor_callPropertyNotAvailable() {
         /* Given */
-        val m: Methods = mock()
+        val m: SynchronousFunctions = mock()
 
         /* When */
         m.int(1)
@@ -259,7 +259,7 @@ class ArgumentCaptorTest : TestBase() {
     @Test
     fun argumentCaptor_vararg() {
         /* Given */
-        val m: Methods = mock()
+        val m: SynchronousFunctions = mock()
 
         /* When */
         m.varargBooleanResult("a", "b", "c")
@@ -273,7 +273,7 @@ class ArgumentCaptorTest : TestBase() {
     @Test
     fun argumentCaptor_empty_vararg() {
         /* Given */
-        val m: Methods = mock()
+        val m: SynchronousFunctions = mock()
 
         /* When */
         m.varargBooleanResult()
@@ -287,7 +287,7 @@ class ArgumentCaptorTest : TestBase() {
     @Test
     fun argumentCaptor_arg_vararg() {
         /* Given */
-        val m: Methods = mock()
+        val m: SynchronousFunctions = mock()
 
         /* When */
         m.argAndVararg("first", "a", "b", "c")
@@ -301,7 +301,7 @@ class ArgumentCaptorTest : TestBase() {
     @Test
     fun argumentCaptor_intarray() {
         /* Given */
-        val m: Methods = mock()
+        val m: SynchronousFunctions = mock()
 
         /* When */
         m.intArray(intArrayOf(1, 2, 3))
@@ -315,7 +315,7 @@ class ArgumentCaptorTest : TestBase() {
     @Test
     fun argumentCaptor_array() {
         /* Given */
-        val m: Methods = mock()
+        val m: SynchronousFunctions = mock()
 
         /* When */
         m.stringArray(arrayOf("a", "b", "c"))
@@ -329,7 +329,7 @@ class ArgumentCaptorTest : TestBase() {
     @Test
     fun argumentCaptor_empty_array() {
         /* Given */
-        val m: Methods = mock()
+        val m: SynchronousFunctions = mock()
 
         /* When */
         m.stringArray(arrayOf())
@@ -343,7 +343,7 @@ class ArgumentCaptorTest : TestBase() {
     @Test
     fun argumentCaptor_value_class() {
         /* Given */
-        val m: Methods = mock()
+        val m: SynchronousFunctions = mock()
         val valueClass = ValueClass("Content")
 
         /* When */
@@ -358,7 +358,7 @@ class ArgumentCaptorTest : TestBase() {
     @Test
     fun argumentCaptor_value_class_withNullValue_usingNonNullable() {
         /* Given */
-        val m: Methods = mock()
+        val m: SynchronousFunctions = mock()
 
         /* When */
         m.nullableValueClass(null)
@@ -372,7 +372,7 @@ class ArgumentCaptorTest : TestBase() {
     @Test
     fun argumentCaptor_value_class_withNullValue_usingNullable() {
         /* Given */
-        val m: Methods = mock()
+        val m: SynchronousFunctions = mock()
 
         /* When */
         m.nullableValueClass(null)
diff --git a/tests/src/test/kotlin/test/BDDMockitoTest.kt b/tests/src/test/kotlin/test/BDDMockitoTest.kt
index 0472163f..457bf406 100644
--- a/tests/src/test/kotlin/test/BDDMockitoTest.kt
+++ b/tests/src/test/kotlin/test/BDDMockitoTest.kt
@@ -10,7 +10,7 @@ class BDDMockitoTest {
     @Test
     fun given_will_properlyStubs() {
         /* Given */
-        val mock = mock<Methods>()
+        val mock = mock<SynchronousFunctions>()
 
         /* When */
         given(mock.stringResult()) will Answer<String> { "Test" }
@@ -22,7 +22,7 @@ class BDDMockitoTest {
     @Test
     fun given_willReturn_properlyStubs() {
         /* Given */
-        val mock = mock<Methods>()
+        val mock = mock<SynchronousFunctions>()
 
         /* When */
         given(mock.stringResult()).willReturn("Test")
@@ -34,7 +34,7 @@ class BDDMockitoTest {
     @Test
     fun givenLambda_willReturn_properlyStubs() {
         /* Given */
-        val mock = mock<Methods>()
+        val mock = mock<SynchronousFunctions>()
 
         /* When */
         given { mock.stringResult() }.willReturn("Test")
@@ -46,7 +46,7 @@ class BDDMockitoTest {
     @Test
     fun given_willReturnLambda_properlyStubs() {
         /* Given */
-        val mock = mock<Methods>()
+        val mock = mock<SynchronousFunctions>()
 
         /* When */
         given(mock.stringResult()).willReturn { "Test" }
@@ -58,7 +58,7 @@ class BDDMockitoTest {
     @Test
     fun givenLambda_willReturnLambda_properlyStubs() {
         /* Given */
-        val mock = mock<Methods>()
+        val mock = mock<SynchronousFunctions>()
 
         /* When */
         given { mock.stringResult() } willReturn { "Test" }
@@ -70,7 +70,7 @@ class BDDMockitoTest {
     @Test
     fun given_willAnswer_properlyStubs() {
         /* Given */
-        val mock = mock<Methods>()
+        val mock = mock<SynchronousFunctions>()
 
         /* When */
         given(mock.stringResult()).willAnswer { "Test" }
@@ -82,7 +82,7 @@ class BDDMockitoTest {
     @Test
     fun given_willAnswerInfix_properlyStubs() {
         /* Given */
-        val mock = mock<Methods>()
+        val mock = mock<SynchronousFunctions>()
 
         /* When */
         given(mock.stringResult()) willAnswer { "Test" }
@@ -94,7 +94,7 @@ class BDDMockitoTest {
     @Test
     fun given_willAnswerInfix_withInvocationInfo_properlyStubs() {
         /* Given */
-        val mock = mock<Methods>()
+        val mock = mock<SynchronousFunctions>()
 
         /* When */
         given(mock.stringResult(any())) willAnswer { invocation ->
@@ -109,7 +109,7 @@ class BDDMockitoTest {
     @Test(expected = IllegalStateException::class)
     fun given_willThrowInfix_properlyStubs() {
         /* Given */
-        val mock = mock<Methods>()
+        val mock = mock<SynchronousFunctions>()
 
         /* When */
         given(mock.stringResult()) willThrow { IllegalStateException() }
@@ -119,13 +119,13 @@ class BDDMockitoTest {
     @Test
     fun then() {
         /* Given */
-        val mock = mock<Methods>()
+        val mock = mock<SynchronousFunctions>()
         whenever(mock.stringResult()).thenReturn("Test")
 
         /* When */
         mock.stringResult()
 
         /* Then */
-        org.mockito.kotlin.then(mock).should().stringResult()
+        then(mock).should().stringResult()
     }
 }
diff --git a/tests/src/test/kotlin/test/Classes.kt b/tests/src/test/kotlin/test/Classes.kt
index d88c766d..4830233d 100644
--- a/tests/src/test/kotlin/test/Classes.kt
+++ b/tests/src/test/kotlin/test/Classes.kt
@@ -1,5 +1,7 @@
 package test
 
+import kotlinx.coroutines.delay
+
 /*
 * The MIT License
 *
@@ -42,11 +44,9 @@ open class Open {
 
 class Closed
 
-interface Methods {
-
+interface SynchronousFunctions {
     fun closed(c: Closed)
     fun classClosed(c: Class<Closed>)
-    suspend fun coroutinesClosed(c: Closed)
     fun closedArray(a: Array<Closed>)
     fun closedNullableArray(a: Array<Closed?>)
     fun closedCollection(c: Collection<Closed>)
@@ -77,10 +77,9 @@ interface Methods {
     fun stringResult(): String
     fun stringResult(s: String): String
     fun nullableStringResult(): String?
-    fun builderMethod(): Methods
+    fun builderMethod(): SynchronousFunctions
     fun varargBooleanResult(vararg values: String): Boolean
-    suspend fun coroutinesClosedBooleanResult(c: Closed): Boolean
-    suspend fun coroutinesClassClosedBooleanResult(c: Class<Closed>): Boolean
+    fun varargStringResult(vararg values: String): String
     fun stringArray(a: Array<String>)
     fun argAndVararg(s: String, vararg a: String)
 
@@ -89,6 +88,23 @@ interface Methods {
     fun valueClass(v: ValueClass)
     fun nullableValueClass(v: ValueClass?)
     fun nestedValueClass(v: NestedValueClass)
+    fun valueClassResult(): ValueClass
+    fun nullableValueClassResult(): ValueClass?
+    fun nestedValueClassResult(): NestedValueClass
+}
+
+interface SuspendFunctions {
+    suspend fun closed(c: Closed)
+    suspend fun closedBooleanResult(c: Closed): Boolean
+    suspend fun classClosedBooleanResult(c: Class<Closed>): Boolean
+    suspend fun stringResult(): String
+    suspend fun stringResult(s: String): String
+    suspend fun stringResult(s1: String, s2: String): String
+    suspend fun nullableStringResult(): String?
+    suspend fun valueClassResult(): ValueClass
+    suspend fun nullableValueClassResult(): ValueClass?
+    suspend fun nestedValueClassResult(): NestedValueClass
+    suspend fun builderMethod(): SuspendFunctions
 }
 
 @JvmInline
diff --git a/tests/src/test/kotlin/test/CoroutinesOngoingStubbingTest.kt b/tests/src/test/kotlin/test/CoroutinesOngoingStubbingTest.kt
new file mode 100644
index 00000000..91be842e
--- /dev/null
+++ b/tests/src/test/kotlin/test/CoroutinesOngoingStubbingTest.kt
@@ -0,0 +1,344 @@
+package test
+
+import com.nhaarman.expect.expect
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import org.junit.Ignore
+import org.junit.Test
+import org.mockito.Mockito
+import org.mockito.kotlin.any
+import org.mockito.kotlin.mock
+import org.mockito.stubbing.Answer
+
+class CoroutinesOngoingStubbingTest {
+    @Test
+    fun `should mock suspendable methodCall`() {
+        /* Given */
+        val mock = mock<SuspendFunctions> {
+            onBlocking { stringResult() } doReturn "A"
+        }
+
+        /* When */
+        val result = runBlocking { mock.stringResult() }
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+
+    @Test
+    fun `should mock suspendable methodCall within a coroutine scope`() = runTest {
+        /* Given */
+        val mock = mock<SuspendFunctions> {
+            onBlocking { stringResult() } doReturn "A"
+        }
+
+        /* When */
+        val result = mock.stringResult()
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+
+    @Test
+    fun `should mock consecutive suspendable methodCalls`() {
+        /* Given */
+        val mock = mock<SuspendFunctions> {
+            onBlocking { stringResult() }.doReturn("A", "B", "C")
+        }
+
+        /* When */
+        val result = runBlocking {
+            (1..3).map { _ ->
+                mock.stringResult()
+            }
+        }
+
+        /* Then */
+        expect(result).toBe(listOf("A", "B", "C"))
+    }
+
+    @Test
+    fun `should mock consecutive suspendable methodCalls by a list of answers`() {
+        /* Given */
+        val mock = mock<SuspendFunctions> {
+            onBlocking { stringResult() } doReturnConsecutively listOf("A", "B", "C")
+        }
+
+        /* When */
+        val result = runBlocking {
+            (1..3).map { _ ->
+                mock.stringResult()
+            }
+        }
+
+        /* Then */
+        expect(result).toBe(listOf("A", "B", "C"))
+    }
+
+    @Ignore("Default answers do not yet work for coroutines, see https://github.com/mockito/mockito-kotlin/issues/550")
+    @Test
+    fun `should mock builder method returning mock itself via defaultAnswer`() {
+        /* Given */
+        val mock = mock<SuspendFunctions>(defaultAnswer = Mockito.RETURNS_SELF)
+
+        /* When */
+        val result = runBlocking { mock.builderMethod() }
+
+        /* Then */
+        expect(result).toBeTheSameAs(mock)
+    }
+
+    @Ignore("Default answers do not yet work for coroutines, see https://github.com/mockito/mockito-kotlin/issues/550")
+    @Test
+    fun `should mock builder method returning mock itself via answer`() {
+        /* Given */
+        val mock = mock<SuspendFunctions> {
+            onBlocking { builderMethod() } doAnswer Mockito.RETURNS_SELF
+        }
+
+        /* When */
+        val result = runBlocking { mock.builderMethod() }
+
+        /* Then */
+        expect(result).toBeTheSameAs(mock)
+    }
+
+    @Test
+    fun `should mock builder method returning mock itself`() {
+        /* Given */
+        val mock = mock<SuspendFunctions> { mock ->
+            onBlocking { builderMethod() } doReturn mock
+        }
+
+        /* When */
+        val result = runBlocking { mock.builderMethod() }
+
+        /* Then */
+        expect(result).toBe(mock)
+    }
+
+    @Test
+    fun `should mock suspendable methodCall with nullable result`() {
+        /* Given */
+        val mock = mock<SuspendFunctions> {
+            onBlocking { nullableStringResult() } doReturn "Test"
+        }
+
+        /* When */
+        val result = runBlocking { mock.nullableStringResult() }
+
+        /* Then */
+        expect(result).toBe("Test")
+    }
+
+    @Test
+    fun `should throw exception instance on suspendable methodCall`() {
+        /* Given */
+        val mock = mock<SuspendFunctions> {
+            onBlocking { builderMethod() } doThrow IllegalArgumentException()
+        }
+
+        /* When, Then */
+        runBlocking {
+            assertThrows<IllegalArgumentException> {
+                mock.builderMethod()
+            }
+        }
+    }
+
+    @Test
+    fun `should throw exception class on suspendable methodCall`() {
+        /* Given */
+        val mock = mock<SuspendFunctions> {
+            onBlocking { builderMethod() } doThrow IllegalArgumentException::class
+        }
+
+        /* When, Then */
+        runBlocking {
+            assertThrows<IllegalArgumentException> {
+                mock.builderMethod()
+            }
+        }
+    }
+
+    @Test
+    fun `should throw exception instances on consecutive suspendable methodCalls`() {
+        /* Given */
+        val mock = mock<SuspendFunctions> {
+            onBlocking { builderMethod() }.doThrow(
+                IllegalArgumentException(),
+                UnsupportedOperationException()
+            )
+        }
+
+        /* When, Then */
+        runBlocking {
+            assertThrows<IllegalArgumentException> {
+                mock.builderMethod()
+            }
+            assertThrows<UnsupportedOperationException> {
+                mock.builderMethod()
+            }
+        }
+    }
+
+    @Test
+    fun `should throw exception classes on consecutive suspendable methodCalls`() {
+        /* Given */
+        val mock = mock<SuspendFunctions> {
+            onBlocking { builderMethod() }.doThrow(
+                IllegalArgumentException::class,
+                UnsupportedOperationException::class
+            )
+        }
+
+        /* When, Then */
+        runBlocking {
+            assertThrows<IllegalArgumentException> {
+                mock.builderMethod()
+            }
+            assertThrows<UnsupportedOperationException> {
+                mock.builderMethod()
+            }
+        }
+    }
+
+    @Test
+    fun `should mock suspendable methodCall with result from answer instance`() {
+        /* Given */
+        val answer: Answer<String> = Answer { "result" }
+        val mock = mock<SuspendFunctions> {
+            onBlocking { stringResult() } doAnswer answer
+        }
+
+        /* When */
+
+        val result = runBlocking { mock.stringResult() }
+
+        /* Then */
+        expect(result).toBe("result")
+    }
+
+    @Test
+    fun `should mock suspendable methodCall with result from lambda`() {
+        /* Given */
+        val mock = mock<SuspendFunctions> {
+            onBlocking { stringResult() } doAnswer { "result" }
+        }
+
+        /* When */
+        val result = runBlocking { mock.stringResult() }
+
+        /* Then */
+        expect(result).toBe("result")
+    }
+
+    @Test
+    fun `should mock suspendable methodCall with result from lambda with argument`() {
+        /* Given */
+        val mock = mock<SuspendFunctions> {
+            onBlocking { stringResult(any()) } doAnswer { "${it.arguments[0]}-result" }
+        }
+
+        /* When */
+        val result = runBlocking { mock.stringResult("argument") }
+
+        /* Then */
+        expect(result).toBe("argument-result")
+    }
+
+    @Test
+    fun `should mock suspendable methodCall with result from lambda with deconstructed argument`() {
+        /* Given */
+        val mock = mock<SuspendFunctions> {
+            onBlocking { stringResult(any()) } doAnswer { (s: String) -> "$s-result" }
+        }
+
+        /* When */
+        val result = runBlocking { mock.stringResult("argument") }
+
+        /* Then */
+        expect(result).toBe("argument-result")
+    }
+
+    @Test
+    fun `should mock suspendable methodCall with result from lambda with deconstructed arguments`() {
+        /* Given */
+        val mock = mock<SuspendFunctions> {
+            onBlocking { stringResult(any(), any()) } doAnswer { (a: String, b: String) ->
+                "$a + $b"
+            }
+        }
+
+        /* When */
+        val result = runBlocking { mock.stringResult("apple", "banana") }
+
+        /* Then */
+        expect(result).toBe("apple + banana")
+    }
+
+    @Test
+    fun `should mock suspendable methodCall with value class result`() {
+        /* Given */
+        val valueClass = ValueClass("A")
+        val mock = mock<SuspendFunctions> {
+            onBlocking { valueClassResult() } doReturn valueClass
+        }
+
+        /* When */
+        val result: ValueClass = runBlocking { mock.valueClassResult() }
+
+        /* Then */
+        expect(result).toBe(valueClass)
+    }
+
+    @Test
+    fun `should mock suspendable methodCall with nullable value class result`() {
+        /* Given */
+        val valueClass = ValueClass("A")
+        val mock = mock<SuspendFunctions> {
+            onBlocking { nullableValueClassResult() } doReturn valueClass
+        }
+
+        /* When */
+        val result: ValueClass? = runBlocking { mock.nullableValueClassResult() }
+
+        /* Then */
+        expect(result).toBe(valueClass)
+    }
+
+    @Test
+    fun `should mock consecutive suspendable methodCall with value class results`() {
+        /* Given */
+        val valueClassA = ValueClass("A")
+        val valueClassB = ValueClass("B")
+        val mock = mock<SuspendFunctions> {
+            onBlocking { valueClassResult() }.doReturnConsecutively(valueClassA, valueClassB)
+        }
+
+        /* When */
+        val (result1, result2) = runBlocking {
+            mock.valueClassResult() to mock.valueClassResult()
+        }
+
+        /* Then */
+        expect(result1).toBe(valueClassA)
+        expect(result2).toBe(valueClassB)
+    }
+
+    @Test
+    fun `should mock suspendable methodCall with nested value class result`() {
+        /* Given */
+        val nestedValueClass = NestedValueClass(ValueClass("A"))
+        val mock = mock<SuspendFunctions> {
+            onBlocking { nestedValueClassResult() } doReturn nestedValueClass
+        }
+
+        /* When */
+        val result: NestedValueClass = runBlocking { mock.nestedValueClassResult() }
+
+        /* Then */
+        expect(result).toBe(nestedValueClass)
+        expect(result.value).toBe(nestedValueClass.value)
+    }
+}
diff --git a/tests/src/test/kotlin/test/CoroutinesTest.kt b/tests/src/test/kotlin/test/CoroutinesTest.kt
new file mode 100644
index 00000000..336a032d
--- /dev/null
+++ b/tests/src/test/kotlin/test/CoroutinesTest.kt
@@ -0,0 +1,513 @@
+//@file:Suppress("EXPERIMENTAL_FEATURE_WARNING")
+
+package test
+
+import com.nhaarman.expect.expect
+import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.actor
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Test
+import org.mockito.InOrder
+import org.mockito.kotlin.*
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.inOrder
+import java.util.*
+
+class CoroutinesTest {
+
+    @Test
+    fun stubbingSuspending() {
+        /* Given */
+        val mock = mock<SuspendFunctions> {
+            onBlocking { stringResult() } doReturn "Value"
+        }
+
+        /* When */
+        val result = runBlocking { mock.stringResult() }
+
+        /* Then */
+        expect(result).toBe("Value")
+    }
+
+    @Test
+    fun stubbingSuspending_usingSuspendingFunction() {
+        /* Given */
+        val mock = mock<SuspendFunctions> {
+            onBlocking { stringResult() } doReturn runBlocking { SomeClass().result("Value") }
+        }
+
+        /* When */
+        val result = runBlocking { mock.stringResult() }
+
+        /* Then */
+        expect(result).toBe("Value")
+    }
+
+    @Test
+    fun stubbingSuspending_runBlocking() = runBlocking {
+        /* Given */
+        val mock = mock<SuspendFunctions> {
+            onBlocking { stringResult() } doReturn "Value"
+        }
+
+        /* When */
+        val result = mock.stringResult()
+
+        /* Then */
+        expect(result).toBe("Value")
+    }
+
+    @Test
+    fun stubbingSuspending_wheneverBlocking() {
+        /* Given */
+        val mock: SuspendFunctions = mock()
+        wheneverBlocking { mock.stringResult() }
+            .doReturn("Value")
+
+        /* When */
+        val result = runBlocking { mock.stringResult() }
+
+        /* Then */
+        expect(result).toBe("Value")
+    }
+
+    @Test
+    fun stubbingSuspending_doReturn() {
+        /* Given */
+        val mock = spy(SomeClass())
+        doReturn("Value").wheneverBlocking(mock) { delaying() }
+
+        /* When */
+        val result = runBlocking { mock.delaying() }
+
+        /* Then */
+        expect(result).toBe("Value")
+    }
+
+    @Test
+    fun stubbingNonSuspending() {
+        /* Given */
+        val mock = mock<SynchronousFunctions> {
+            onBlocking { stringResult() } doReturn "Value"
+        }
+
+        /* When */
+        val result = mock.stringResult()
+
+        /* Then */
+        expect(result).toBe("Value")
+    }
+
+    @Test
+    fun stubbingNonSuspending_runBlocking() = runBlocking {
+        /* Given */
+        val mock = mock<SynchronousFunctions> {
+            onBlocking { stringResult() } doReturn "Value"
+        }
+
+        /* When */
+        val result = mock.stringResult()
+
+        /* Then */
+        expect(result).toBe("Value")
+    }
+
+    @Test
+    fun delayingResult() {
+        /* Given */
+        val instance = SomeClass()
+
+        /* When */
+        val result = runBlocking { instance.delaying() }
+
+        /* Then */
+        expect(result).toBe("Value")
+    }
+
+    @Test
+    fun delayingResult_runBlocking() = runBlocking {
+        /* Given */
+        val instance = SomeClass()
+
+        /* When */
+        val result = instance.delaying()
+
+        /* Then */
+        expect(result).toBe("Value")
+    }
+
+    @Test
+    fun verifySuspendFunctionCalled() {
+        /* Given */
+        val mock = mock<SuspendFunctions>()
+
+        /* When */
+        runBlocking { mock.stringResult() }
+
+        /* Then */
+        runBlocking { verify(mock).stringResult() }
+    }
+
+    @Test
+    fun verifySuspendFunctionCalled_runBlocking() = runBlocking<Unit> {
+        val mock = mock<SuspendFunctions>()
+
+        mock.stringResult()
+
+        verify(mock).stringResult()
+    }
+
+    @Test
+    fun verifySuspendFunctionCalled_verifyBlocking() {
+        val mock = mock<SuspendFunctions>()
+
+        runBlocking { mock.stringResult() }
+
+        verifyBlocking(mock) { stringResult() }
+    }
+
+    @Test
+    fun verifyAtLeastOnceSuspendFunctionCalled_verifyBlocking() {
+        val mock = mock<SuspendFunctions>()
+
+        runBlocking { mock.stringResult() }
+        runBlocking { mock.stringResult() }
+
+        verifyBlocking(mock, atLeastOnce()) { stringResult() }
+    }
+
+    @Test
+    fun verifySuspendMethod() = runBlocking {
+        val mock: SuspendFunctions = mock()
+
+        mock.stringResult()
+
+        inOrder(mock) {
+            verify(mock).stringResult()
+        }
+    }
+
+    @Test
+    fun answerWithSuspendFunction() = runBlocking {
+        val mock: SuspendFunctions = mock()
+
+        wheneverBlocking {mock.stringResult(any()) } doAnswer { it.single() }
+
+        assertEquals("Value", mock.stringResult("Value"))
+    }
+
+    @Test
+    fun inplaceAnswerWithSuspendFunction() = runBlocking {
+        val mock: SuspendFunctions = mock {
+            onBlocking { stringResult(any()) } doAnswer { it.single() }
+        }
+
+        assertEquals("Value", mock.stringResult("Value"))
+    }
+
+    @Test
+    fun callFromSuspendFunction() = runBlocking {
+        val mock: SuspendFunctions = mock()
+
+        wheneverBlocking {mock.stringResult(any()) } doAnswer { it.single() }
+
+        val result = async {
+            val answer = mock.stringResult("Value")
+
+            Result.success(answer)
+        }
+
+        assertEquals("Value", result.await().getOrThrow())
+    }
+
+    @Test
+    @OptIn(ObsoleteCoroutinesApi::class)
+    fun callFromActor() = runBlocking {
+        val mock: SuspendFunctions = mock()
+
+        wheneverBlocking { mock.stringResult(any()) } doAnswer { it.single() }
+
+        val actor = actor<Optional<String>> {
+            for (element in channel) {
+                mock.stringResult(element.get())
+            }
+        }
+
+        actor.send(Optional.of("Value"))
+        actor.close()
+
+        verify(mock).stringResult("Value")
+
+        Unit
+    }
+
+    @Test
+    fun answerWithSuspendFunctionWithoutArgs() = runBlocking {
+        val mock: SuspendFunctions = mock()
+
+        wheneverBlocking { mock.stringResult() } doReturn "Value"
+
+        assertEquals("Value", mock.stringResult())
+    }
+
+    @Test
+    fun answerWithSuspendFunctionWithDestructuredArgs() = runBlocking {
+        val mock: SuspendFunctions = mock()
+
+        wheneverBlocking { mock.stringResult(any()) } doAnswer { (s: String) -> s }
+
+        assertEquals("Value", mock.stringResult("Value"))
+    }
+
+    @Test
+    fun willAnswerWithControlledSuspend() = runBlocking {
+        val mock: SuspendFunctions = mock()
+
+        val job = Job()
+
+        wheneverBlocking { mock.stringResult() } doAnswer {
+            job.join()
+            "Value"
+        }
+
+        val asyncTask = async {
+            mock.stringResult()
+        }
+
+        job.complete()
+
+        withTimeout(100) {
+            assertEquals("Value", asyncTask.await())
+        }
+    }
+
+    @Test
+    fun stubberAnswerWithSuspendFunction() = runBlocking {
+        val mock: SuspendFunctions = mock()
+
+        doSuspendableAnswer { it.single<Any>() }.whenever(mock).stringResult(any())
+
+        assertEquals("Value", mock.stringResult("Value"))
+    }
+
+    @Test
+    fun stubberCallFromSuspendFunction() = runBlocking {
+        val mock: SuspendFunctions = mock()
+
+        doSuspendableAnswer { it.single<Any>() }.whenever(mock).stringResult(any())
+
+        val result = async {
+            val answer = mock.stringResult("Value")
+
+            Result.success(answer)
+        }
+
+        assertEquals("Value", result.await().getOrThrow())
+    }
+
+    @Test
+    @OptIn(ObsoleteCoroutinesApi::class)
+    fun stubberCallFromActor() {
+        val mock: SuspendFunctions = mock()
+
+        doSuspendableAnswer {
+            withContext(Dispatchers.Default) { it.single<Any>() }
+        }.wheneverBlocking(mock) { stringResult(any()) }
+
+        runBlocking {
+            val actor = actor<Optional<String>> {
+                for (element in channel) {
+                    mock.stringResult(element.get())
+                }
+            }
+
+            actor.send(Optional.of("Value"))
+            actor.close()
+        }
+
+        verifyBlocking(mock) {stringResult("Value") }
+    }
+
+    @Test
+    fun stubberAnswerWithSuspendFunctionWithoutArgs() {
+        val mock: SuspendFunctions = mock()
+
+        doSuspendableAnswer {
+            withContext(Dispatchers.Default) { "Value" }
+        }.wheneverBlocking(mock) { stringResult() }
+
+        assertEquals("Value", runBlocking { mock.stringResult() })
+    }
+
+    @Test
+    fun stubberAnswerWithSuspendFunctionWithDestructuredArgs() {
+        val mock: SuspendFunctions = mock()
+
+        doSuspendableAnswer { (s: String) ->
+            withContext(Dispatchers.Default) { s }
+        }.wheneverBlocking(mock) { stringResult(any()) }
+
+        assertEquals("Value", runBlocking {mock.stringResult("Value") })
+    }
+
+    @Test
+    fun stubberWillAnswerWithControlledSuspend() {
+        val mock: SuspendFunctions = mock()
+
+        val job = Job()
+
+        doSuspendableAnswer {
+            job.join()
+            "Value"
+        }.wheneverBlocking(mock) { stringResult() }
+
+        runBlocking {
+            val asyncTask = async {
+                mock.stringResult()
+            }
+
+            job.complete()
+
+            withTimeout(100) {
+                assertEquals("Value", asyncTask.await())
+            }
+        }
+    }
+
+    @Test
+    fun inOrderRemainsCompatible() {
+        /* Given */
+        val mock: SuspendFunctions = mock()
+
+        /* When */
+        val inOrder = inOrder(mock)
+
+        /* Then */
+        expect(inOrder).toBeInstanceOf<InOrder>()
+    }
+
+    @Test
+    fun inOrderSuspendingCalls() {
+        /* Given */
+        val fixtureOne: SuspendFunctions = mock()
+        val fixtureTwo: SuspendFunctions = mock()
+
+        /* When */
+        runBlocking {
+            fixtureOne.stringResult()
+            fixtureTwo.stringResult()
+        }
+
+        /* Then */
+        val inOrder = inOrder(fixtureOne, fixtureTwo)
+        inOrder.verifyBlocking(fixtureOne) { stringResult() }
+        inOrder.verifyBlocking(fixtureTwo) { stringResult() }
+    }
+
+    @Test
+    fun inOrderSuspendingCallsFailure() {
+        /* Given */
+        val fixtureOne: SuspendFunctions = mock()
+        val fixtureTwo: SuspendFunctions = mock()
+
+        /* When */
+        runBlocking {
+            fixtureOne.stringResult()
+            fixtureTwo.stringResult()
+        }
+
+        /* Then */
+        val inOrder = inOrder(fixtureOne, fixtureTwo)
+        inOrder.verifyBlocking(fixtureTwo) { stringResult() }
+        assertThrows(AssertionError::class.java) {
+            inOrder.verifyBlocking(fixtureOne) { stringResult() }
+        }
+    }
+
+    @Test
+    fun inOrderBlockSuspendingCalls() {
+        /* Given */
+        val fixtureOne: SuspendFunctions = mock()
+        val fixtureTwo: SuspendFunctions = mock()
+
+        /* When */
+        runBlocking {
+            fixtureOne.stringResult()
+            fixtureTwo.stringResult()
+        }
+
+        /* Then */
+        inOrder(fixtureOne, fixtureTwo) {
+            verifyBlocking(fixtureOne) { stringResult() }
+            verifyBlocking(fixtureTwo) { stringResult() }
+        }
+    }
+
+    @Test
+    fun inOrderBlockSuspendingCallsFailure() {
+        /* Given */
+        val fixtureOne: SuspendFunctions = mock()
+        val fixtureTwo: SuspendFunctions = mock()
+
+        /* When */
+        runBlocking {
+            fixtureOne.stringResult()
+            fixtureTwo.stringResult()
+        }
+
+        /* Then */
+        inOrder(fixtureOne, fixtureTwo) {
+            verifyBlocking(fixtureTwo) { stringResult() }
+            assertThrows(AssertionError::class.java) {
+                verifyBlocking(fixtureOne) { stringResult() }
+            }
+        }
+    }
+
+    @Test
+    fun inOrderOnObjectSuspendingCalls() {
+        /* Given */
+        val mock: SuspendFunctions = mock()
+
+        /* When */
+        runBlocking {
+            mock.stringResult("Value")
+            mock.stringResult("Other Value")
+        }
+
+        /* Then */
+        mock.inOrder {
+            verifyBlocking { stringResult("Value") }
+            verifyBlocking { stringResult("Other Value") }
+        }
+    }
+
+    @Test
+    fun inOrderOnObjectSuspendingCallsFailure() {
+        /* Given */
+        val mock: SuspendFunctions = mock()
+
+        /* When */
+        runBlocking {
+            mock.stringResult("Value")
+            mock.stringResult("Other Value")
+        }
+
+        /* Then */
+        mock.inOrder {
+            verifyBlocking { stringResult("Other Value") }
+            assertThrows(AssertionError::class.java) {
+                verifyBlocking { stringResult("Value") }
+            }
+        }
+    }
+}
+
+open class SomeClass {
+    suspend fun result(r: String) = withContext(Dispatchers.Default) { r }
+    open suspend fun delaying() = withContext(Dispatchers.Default) {
+        delay(100)
+        "Value"
+    }
+}
diff --git a/tests/src/test/kotlin/test/JUnit4Utils.kt b/tests/src/test/kotlin/test/JUnit4Utils.kt
new file mode 100644
index 00000000..4e6b053f
--- /dev/null
+++ b/tests/src/test/kotlin/test/JUnit4Utils.kt
@@ -0,0 +1,13 @@
+package test
+
+import junit.framework.AssertionFailedError
+
+/** Inspired by JUnit5, asserts an exception being thrown */
+inline fun <reified E: Throwable> assertThrows(block: () -> Unit): E {
+    return try {
+        block.invoke()
+        throw AssertionFailedError("No exception of type ${(E::class).simpleName} was thrown")
+    } catch (e: Throwable) {
+        e as? E ?: throw e
+    }
+}
diff --git a/tests/src/test/kotlin/test/MatchersTest.kt b/tests/src/test/kotlin/test/MatchersTest.kt
index 9fe1eeea..eb87562d 100644
--- a/tests/src/test/kotlin/test/MatchersTest.kt
+++ b/tests/src/test/kotlin/test/MatchersTest.kt
@@ -17,7 +17,7 @@ class MatchersTest : TestBase() {
     class AnyMatchersTest {
         @Test
         fun anyString() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 string("")
                 verify(this).string(any())
             }
@@ -25,7 +25,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyNullableString() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 nullableString("")
                 verify(this).nullableString(any())
             }
@@ -33,7 +33,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyBoolean() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 boolean(true)
                 verify(this).boolean(any())
             }
@@ -41,7 +41,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyBooleanArray() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 booleanArray(booleanArrayOf(true, false, false))
                 verify(this).booleanArray(any())
             }
@@ -49,7 +49,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyChar() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 char('3')
                 verify(this).char(any())
             }
@@ -57,7 +57,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyCharArray() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 charArray(charArrayOf('3', '4', '5'))
                 verify(this).charArray(any())
             }
@@ -65,7 +65,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyByte() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 byte(3)
                 verify(this).byte(any())
             }
@@ -73,7 +73,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyByteArray() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 byteArray(byteArrayOf(3, 4, 5))
                 verify(this).byteArray(any())
             }
@@ -81,7 +81,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyShort() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 short(3)
                 verify(this).short(any())
             }
@@ -89,7 +89,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyShortArray() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 shortArray(shortArrayOf(3, 4, 5))
                 verify(this).shortArray(any())
             }
@@ -97,7 +97,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyInt() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 int(3)
                 verify(this).int(any())
             }
@@ -105,7 +105,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyIntArray() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 intArray(intArrayOf(3, 4, 5))
                 verify(this).intArray(any())
             }
@@ -113,7 +113,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyLong() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 long(3)
                 verify(this).long(any())
             }
@@ -121,7 +121,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyLongArray() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 longArray(longArrayOf(3L, 4L, 5L))
                 verify(this).longArray(any())
             }
@@ -129,7 +129,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyFloat() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 float(3f)
                 verify(this).float(any())
             }
@@ -137,7 +137,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyFloatArray() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 floatArray(floatArrayOf(3f, 4f, 5f))
                 verify(this).floatArray(any())
             }
@@ -145,7 +145,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyDouble() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 double(3.0)
                 verify(this).double(any())
             }
@@ -153,7 +153,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyDoubleArray() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 doubleArray(doubleArrayOf(3.0, 4.0, 5.0))
                 verify(this).doubleArray(any())
             }
@@ -161,7 +161,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyClosedClass() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 closed(Closed())
                 verify(this).closed(any())
             }
@@ -169,26 +169,25 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyClassClosedClass() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 classClosed(Closed::class.java)
                 verify(this).classClosed(any())
             }
         }
 
         @Test
-        fun anyCoroutinesClosedClass() {
-            mock<Methods>().apply {
-                runTest {
-                    coroutinesClosed(Closed())
-                    verify(this@apply).coroutinesClosed(any())
-                }
-            }
+        fun anySuspendMethodClosedClass() = runTest {
+            val mock = mock<SuspendFunctions>()
+
+            mock.closed(Closed())
+
+            verify(mock).closed(any())
         }
 
         /** https://github.com/nhaarman/mockito-kotlin/issues/27 */
         @Test
         fun anyThrowableWithSingleThrowableConstructor() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 throwableClass(ThrowableClass(IOException()))
                 verify(this).throwableClass(any())
             }
@@ -196,7 +195,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyValueClass() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 valueClass(ValueClass("Content"))
                 verify(this).valueClass(any())
             }
@@ -204,7 +203,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyNeverVerifiesForNullValue() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 nullableString(null)
                 verify(this, never()).nullableString(any())
             }
@@ -214,7 +213,7 @@ class MatchersTest : TestBase() {
     class SpecialAnyMatchersTest {
         @Test
         fun anyClassArray() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 closedArray(arrayOf(Closed()))
                 verify(this).closedArray(anyArray())
             }
@@ -222,7 +221,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyNullableClassArray() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 closedNullableArray(arrayOf(Closed(), null))
                 verify(this).closedNullableArray(anyArray())
             }
@@ -230,7 +229,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyStringVararg() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 closedVararg(Closed(), Closed())
                 verify(this).closedVararg(anyVararg())
             }
@@ -238,7 +237,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyVarargMatching() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 whenever(varargBooleanResult(anyVararg())).thenReturn(true)
                 expect(varargBooleanResult()).toBe(true)
             }
@@ -246,7 +245,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyValueClass_withValueClass() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 valueClass(ValueClass("Content"))
                 verify(this).valueClass(anyValueClass())
             }
@@ -255,7 +254,7 @@ class MatchersTest : TestBase() {
         @Test
         fun anyValueClass_withNonValueClass() {
             expectErrorWithMessage("kotlin.Float is not a value class.") on {
-                mock<Methods>().apply {
+                mock<SynchronousFunctions>().apply {
                     float(10f)
                     // Should throw an error because Float is not a value class
                     float(anyValueClass())
@@ -265,7 +264,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyValueClass_withNestedValueClass() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 nestedValueClass(NestedValueClass(ValueClass("Content")))
                 verify(this).nestedValueClass(anyValueClass())
             }
@@ -275,7 +274,7 @@ class MatchersTest : TestBase() {
     class AnyOrNullMatchersTest {
         @Test
         fun anyOrNullString() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 string("")
                 verify(this).string(anyOrNull())
             }
@@ -283,7 +282,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyOrNullNullableString() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 nullableString("")
                 verify(this).nullableString(anyOrNull())
             }
@@ -291,7 +290,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyOrNullNullableStringNullValue() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 nullableString(null)
                 verify(this).nullableString(anyOrNull())
             }
@@ -299,7 +298,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyOrNullBoolean() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 boolean(false)
                 verify(this).boolean(anyOrNull())
             }
@@ -307,7 +306,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyOrNullByte() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 byte(3)
                 verify(this).byte(anyOrNull())
             }
@@ -315,7 +314,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyOrNullChar() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 char('a')
                 verify(this).char(anyOrNull())
             }
@@ -323,7 +322,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyOrNullShort() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 short(3)
                 verify(this).short(anyOrNull())
             }
@@ -331,7 +330,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyOrNullInt() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 int(3)
                 verify(this).int(anyOrNull())
             }
@@ -339,7 +338,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyOrNullLong() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 long(3)
                 verify(this).long(anyOrNull())
             }
@@ -347,7 +346,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyOrNullFloat() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 float(3f)
                 verify(this).float(anyOrNull())
             }
@@ -355,7 +354,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyOrNullDouble() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 double(3.0)
                 verify(this).double(anyOrNull())
             }
@@ -363,7 +362,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyOrNullValueClass() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 valueClass(ValueClass("Content"))
                 verify(this).valueClass(anyOrNull())
             }
@@ -371,7 +370,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyOrNullNullableValueClass() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 nullableValueClass(ValueClass("Content"))
                 verify(this).nullableValueClass(anyOrNull())
             }
@@ -379,7 +378,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun anyOrNullNullableValueClassNullValue() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 nullableValueClass(null)
                 verify(this).nullableValueClass(anyOrNull())
             }
@@ -390,7 +389,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqString() {
             val value = "Value"
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 string(value)
                 verify(this).string(eq(value))
             }
@@ -399,7 +398,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqBoolean() {
             val value = true
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 boolean(value)
                 verify(this).boolean(eq(value))
             }
@@ -408,7 +407,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqBooleanArray() {
             val value = booleanArrayOf(true, false, false)
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 booleanArray(value)
                 verify(this).booleanArray(eq(value))
             }
@@ -417,7 +416,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqChar() {
             val value = '3'
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 char(value)
                 verify(this).char(eq(value))
             }
@@ -426,7 +425,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqCharArray() {
             val value = charArrayOf('3', '4', '5')
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 charArray(value)
                 verify(this).charArray(eq(value))
             }
@@ -435,7 +434,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqByte() {
             val value: Byte = 3
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 byte(value)
                 verify(this).byte(eq(value))
             }
@@ -444,7 +443,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqByteArray() {
             val value = byteArrayOf(3, 4, 5)
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 byteArray(value)
                 verify(this).byteArray(eq(value))
             }
@@ -453,7 +452,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqShort() {
             val value: Short = 3
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 short(value)
                 verify(this).short(eq(value))
             }
@@ -462,7 +461,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqShortArray() {
             val value = shortArrayOf(3, 4, 5)
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 shortArray(value)
                 verify(this).shortArray(eq(value))
             }
@@ -471,7 +470,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqInt() {
             val value = 3
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 int(value)
                 verify(this).int(eq(value))
             }
@@ -480,7 +479,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqIntArray() {
             val value = intArrayOf(3, 4, 5)
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 intArray(value)
                 verify(this).intArray(eq(value))
             }
@@ -489,7 +488,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqLong() {
             val value = 3L
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 long(value)
                 verify(this).long(eq(value))
             }
@@ -498,7 +497,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqLongArray() {
             val value = longArrayOf(3L, 4L, 5L)
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 longArray(value)
                 verify(this).longArray(eq(value))
             }
@@ -507,7 +506,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqFloat() {
             val value = 3f
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 float(value)
                 verify(this).float(eq(value))
             }
@@ -516,7 +515,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqFloatArray() {
             val value = floatArrayOf(3f, 4f, 5f)
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 floatArray(value)
                 verify(this).floatArray(eq(value))
             }
@@ -525,7 +524,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqDouble() {
             val value = 3.0
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 double(value)
                 verify(this).double(eq(value))
             }
@@ -534,7 +533,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqDoubleArray() {
             val value = doubleArrayOf(3.0, 4.0, 5.0)
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 doubleArray(value)
                 verify(this).doubleArray(eq(value))
             }
@@ -543,7 +542,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqClosedClass() {
             val value = Closed()
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 closed(value)
                 verify(this).closed(eq(value))
             }
@@ -552,27 +551,26 @@ class MatchersTest : TestBase() {
         @Test
         fun eqClassClosedClass() {
             val clazz = Closed::class.java
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 classClosed(clazz)
                 verify(this).classClosed(eq(clazz))
             }
         }
 
         @Test
-        fun eqCoroutinesClosedClass() {
+        fun eqSuspendMethodClosedClass() = runTest {
+            val mock = mock<SuspendFunctions>()
             val value = Closed()
-            mock<Methods>().apply {
-                runTest {
-                    coroutinesClosed(value)
-                    verify(this@apply).coroutinesClosed(eq(value))
-                }
-            }
+
+            mock.closed(value)
+
+            verify(mock).closed(eq(value))
         }
 
         @Test
         fun eqClassArray() {
             val value = arrayOf(Closed())
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 closedArray(value)
                 verify(this).closedArray(eq(value))
             }
@@ -581,7 +579,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqNullableClassArray() {
             val value = arrayOf(Closed(), null)
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 closedNullableArray(value)
                 verify(this).closedNullableArray(eq(value))
             }
@@ -590,7 +588,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqValueClass() {
             val valueClass = ValueClass("Content")
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 valueClass(valueClass)
                 verify(this).valueClass(eq(valueClass))
             }
@@ -599,7 +597,7 @@ class MatchersTest : TestBase() {
         @Test
         fun eqNestedValueClass() {
             val nestedValueClass = NestedValueClass(ValueClass("Content"))
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 nestedValueClass(nestedValueClass)
                 verify(this).nestedValueClass(eq(nestedValueClass))
             }
@@ -609,7 +607,7 @@ class MatchersTest : TestBase() {
     class OtherMatchersTest {
         @Test
         fun listArgThat() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 closedList(listOf(Closed(), Closed()))
                 verify(this).closedList(
                     argThat {
@@ -621,7 +619,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun listArgForWhich() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 closedList(listOf(Closed(), Closed()))
                 verify(this).closedList(
                     argForWhich {
@@ -633,7 +631,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun listArgWhere() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 closedList(listOf(Closed(), Closed()))
                 verify(this).closedList(
                     argWhere {
@@ -645,7 +643,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun listArgCheck() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 closedList(listOf(Closed(), Closed()))
                 verify(this).closedList(
                     check {
@@ -657,7 +655,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun checkProperlyFails() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 closedList(listOf(Closed(), Closed()))
 
                 expectErrorWithMessage("Argument(s) are different!") on {
@@ -672,7 +670,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun checkWithNullArgument_throwsError() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 nullableString(null)
 
                 expectErrorWithMessage("null").on {
@@ -683,7 +681,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun isA_withNonNullableString() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 string("")
                 verify(this).string(isA<String>())
             }
@@ -691,7 +689,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun isA_withNullableString() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 nullableString("")
                 verify(this).nullableString(isA<String>())
             }
@@ -699,7 +697,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun same_withNonNullArgument() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 string("")
                 verify(this).string(same(""))
             }
@@ -707,7 +705,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun same_withNullableNonNullArgument() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 nullableString("")
                 verify(this).nullableString(same(""))
             }
@@ -715,7 +713,7 @@ class MatchersTest : TestBase() {
 
         @Test
         fun same_withNullArgument() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 nullableString(null)
                 verify(this).nullableString(same(null))
             }
@@ -724,7 +722,7 @@ class MatchersTest : TestBase() {
         @Test
         fun testVarargAnySuccess() {
             /* Given */
-            val t = mock<Methods>()
+            val t = mock<SynchronousFunctions>()
             // a matcher to check if any of the varargs was equals to "b"
             val matcher = VarargAnyMatcher({ "b" == it }, String::class.java, true, false)
 
@@ -738,7 +736,7 @@ class MatchersTest : TestBase() {
         @Test
         fun testVarargAnyFail() {
             /* Given */
-            val t = mock<Methods>()
+            val t = mock<SynchronousFunctions>()
             // a matcher to check if any of the varargs was equals to "d"
             val matcher = VarargAnyMatcher({ "d" == it }, String::class.java, true, false)
 
@@ -752,7 +750,7 @@ class MatchersTest : TestBase() {
         /** https://github.com/nhaarman/mockito-kotlin/issues/328 */
         @Test
         fun testRefEqForNonNullableParameter() {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 /* When */
                 val array = intArrayOf(2, 3)
                 intArray(array)
diff --git a/tests/src/test/kotlin/test/MockingTest.kt b/tests/src/test/kotlin/test/MockingTest.kt
index 9a42d3c9..e72a2d53 100644
--- a/tests/src/test/kotlin/test/MockingTest.kt
+++ b/tests/src/test/kotlin/test/MockingTest.kt
@@ -110,7 +110,7 @@ class MockingTest : TestBase() {
     @Test
     fun mock_withCustomDefaultAnswer_parameterName() {
         /* Given */
-        val mock = mock<Methods>(defaultAnswer = Mockito.RETURNS_SELF)
+        val mock = mock<SynchronousFunctions>(defaultAnswer = Mockito.RETURNS_SELF)
 
         /* When */
         val result = mock.builderMethod()
@@ -122,7 +122,7 @@ class MockingTest : TestBase() {
     @Test
     fun mock_withSettingsAPI_extraInterfaces() {
         /* Given */
-        val mock = mock<Methods>(
+        val mock = mock<SynchronousFunctions>(
               extraInterfaces = arrayOf(ExtraInterface::class)
         )
 
@@ -133,7 +133,7 @@ class MockingTest : TestBase() {
     @Test
     fun mock_withSettingsAPI_name() {
         /* Given */
-        val mock = mock<Methods>(name = "myName")
+        val mock = mock<SynchronousFunctions>(name = "myName")
 
         /* When */
         expectErrorWithMessage("myName.stringResult()") on {
@@ -144,7 +144,7 @@ class MockingTest : TestBase() {
     @Test
     fun mock_withSettingsAPI_defaultAnswer() {
         /* Given */
-        val mock = mock<Methods>(defaultAnswer = Mockito.RETURNS_MOCKS)
+        val mock = mock<SynchronousFunctions>(defaultAnswer = Mockito.RETURNS_MOCKS)
 
         /* When */
         val result = mock.nonDefaultReturnType()
@@ -156,7 +156,7 @@ class MockingTest : TestBase() {
     @Test
     fun mock_withSettingsAPI_serializable() {
         /* Given */
-        val mock = mock<Methods>(serializable = true)
+        val mock = mock<SynchronousFunctions>(serializable = true)
 
         /* Then */
         expect(mock).toBeInstanceOf<Serializable>()
@@ -165,7 +165,7 @@ class MockingTest : TestBase() {
     @Test
     fun mock_withSettingsAPI_serializableMode() {
         /* Given */
-        val mock = mock<Methods>(serializableMode = BASIC)
+        val mock = mock<SynchronousFunctions>(serializableMode = BASIC)
 
         /* Then */
         expect(mock).toBeInstanceOf<Serializable>()
@@ -176,18 +176,16 @@ class MockingTest : TestBase() {
         /* Given */
         val out = mock<PrintStream>()
         System.setOut(out)
-        val mock = mock<Methods>(verboseLogging = true)
+        val mock = mock<SynchronousFunctions>(verboseLogging = true)
 
-        try {
-            /* When */
+
+        /* When, Then */
+        assertThrows<WantedButNotInvoked> {
             verify(mock).stringResult()
-            fail("Expected an exception")
-        } catch (e: WantedButNotInvoked) {
-            /* Then */
-            argumentCaptor<DescribedInvocation>().apply {
-                verify(out).println(capture())
-                expect(lastValue.toString()).toBe("methods.stringResult();")
-            }
+        }
+        argumentCaptor<DescribedInvocation>().apply {
+            verify(out).println(capture())
+            expect(lastValue.toString()).toBe("synchronousFunctions.stringResult();")
         }
     }
 
@@ -195,7 +193,7 @@ class MockingTest : TestBase() {
     fun mock_withSettingsAPI_invocationListeners() {
         /* Given */
         var bool = false
-        val mock = mock<Methods>(invocationListeners = arrayOf(InvocationListener { bool = true }))
+        val mock = mock<SynchronousFunctions>(invocationListeners = arrayOf(InvocationListener { bool = true }))
 
         /* When */
         mock.stringResult()
@@ -207,7 +205,7 @@ class MockingTest : TestBase() {
     @Test
     fun mock_withSettingsAPI_stubOnly() {
         /* Given */
-        val mock = mock<Methods>(stubOnly = true)
+        val mock = mock<SynchronousFunctions>(stubOnly = true)
 
         /* Expect */
         expectErrorWithMessage("is a stubOnly() mock") on {
@@ -245,7 +243,7 @@ class MockingTest : TestBase() {
     @Test
     fun mockStubbing_withSettingsAPI_extraInterfaces() {
         /* Given */
-        val mock = mock<Methods>(extraInterfaces = arrayOf(ExtraInterface::class)) {}
+        val mock = mock<SynchronousFunctions>(extraInterfaces = arrayOf(ExtraInterface::class)) {}
 
         /* Then */
         expect(mock).toBeInstanceOf<ExtraInterface>()
@@ -254,7 +252,7 @@ class MockingTest : TestBase() {
     @Test
     fun mockStubbing_withSettingsAPI_name() {
         /* Given */
-        val mock = mock<Methods>(name = "myName") {}
+        val mock = mock<SynchronousFunctions>(name = "myName") {}
 
         /* When */
         expectErrorWithMessage("myName.stringResult()") on {
@@ -265,7 +263,7 @@ class MockingTest : TestBase() {
     @Test
     fun mockStubbing_withSettingsAPIAndStubbing_name() {
         /* Given */
-        val mock = mock<Methods>(name = "myName") {
+        val mock = mock<SynchronousFunctions>(name = "myName") {
             on { nullableStringResult() } doReturn "foo"
         }
 
@@ -277,28 +275,28 @@ class MockingTest : TestBase() {
     }
 
     @Test
-    fun mockCoroutines_withClosedBooleanReturn_name() = runTest {
+    fun mockSuspendMethod_withClosedBooleanReturn_name() = runTest {
         /* Given */
-        val mock = mock<Methods>(name = "myName") {
-            onBlocking { coroutinesClosedBooleanResult(any()) } doReturn true
+        val mock = mock<SuspendFunctions>(name = "myName") {
+            onBlocking { closedBooleanResult(any()) } doReturn true
         }
 
         /* When */
-        val result = mock.coroutinesClosedBooleanResult(Closed())
+        val result = mock.closedBooleanResult(Closed())
 
         /* Then */
         expect(result).toBe(true)
     }
 
     @Test
-    fun mockCoroutines_withClassClosedBooleanReturn_name() = runTest {
+    fun mockSuspendMethod_withClassClosedBooleanReturn_name() = runTest {
         /* Given */
-        val mock = mock<Methods>(name = "myName") {
-            onBlocking { coroutinesClassClosedBooleanResult(any()) } doReturn true
+        val mock = mock<SuspendFunctions>(name = "myName") {
+            onBlocking { classClosedBooleanResult(any()) } doReturn true
         }
 
         /* When */
-        val result = mock.coroutinesClassClosedBooleanResult(Closed::class.java)
+        val result = mock.classClosedBooleanResult(Closed::class.java)
 
         /* Then */
         expect(result).toBe(true)
@@ -307,7 +305,7 @@ class MockingTest : TestBase() {
     @Test
     fun mockStubbing_withSettingsAPI_defaultAnswer() {
         /* Given */
-        val mock = mock<Methods>(defaultAnswer = Mockito.RETURNS_MOCKS) {}
+        val mock = mock<SynchronousFunctions>(defaultAnswer = Mockito.RETURNS_MOCKS) {}
 
         /* When */
         val result = mock.nonDefaultReturnType()
@@ -319,7 +317,7 @@ class MockingTest : TestBase() {
     @Test
     fun mockStubbing_withSettingsAPI_serializable() {
         /* Given */
-        val mock = mock<Methods>(serializable = true) {}
+        val mock = mock<SynchronousFunctions>(serializable = true) {}
 
         /* Then */
         expect(mock).toBeInstanceOf<Serializable>()
@@ -328,7 +326,7 @@ class MockingTest : TestBase() {
     @Test
     fun mockStubbing_withSettingsAPI_serializableMode() {
         /* Given */
-        val mock = mock<Methods>(serializableMode = BASIC) {}
+        val mock = mock<SynchronousFunctions>(serializableMode = BASIC) {}
 
         /* Then */
         expect(mock).toBeInstanceOf<Serializable>()
@@ -339,17 +337,17 @@ class MockingTest : TestBase() {
         /* Given */
         val out = mock<PrintStream>()
         System.setOut(out)
-        val mock = mock<Methods>(verboseLogging = true) {}
+        val mock = mock<SynchronousFunctions>(verboseLogging = true) {}
 
         try {
             /* When */
             verify(mock).stringResult()
             fail("Expected an exception")
-        } catch (e: WantedButNotInvoked) {
+        } catch (_: WantedButNotInvoked) {
             /* Then */
             argumentCaptor<DescribedInvocation>().apply {
                 verify(out).println(capture())
-                expect(lastValue.toString()).toBe("methods.stringResult();")
+                expect(lastValue.toString()).toBe("synchronousFunctions.stringResult();")
             }
         }
     }
@@ -358,7 +356,7 @@ class MockingTest : TestBase() {
     fun mockStubbing_withSettingsAPI_invocationListeners() {
         /* Given */
         var bool = false
-        val mock = mock<Methods>(invocationListeners = arrayOf(InvocationListener { bool = true })) {}
+        val mock = mock<SynchronousFunctions>(invocationListeners = arrayOf(InvocationListener { bool = true })) {}
 
         /* When */
         mock.stringResult()
@@ -370,7 +368,7 @@ class MockingTest : TestBase() {
     @Test
     fun mockStubbing_withSettingsAPI_stubOnly() {
         /* Given */
-        val mock = mock<Methods>(stubOnly = true) {}
+        val mock = mock<SynchronousFunctions>(stubOnly = true) {}
 
         /* Expect */
         expectErrorWithMessage("is a stubOnly() mock") on {
diff --git a/tests/src/test/kotlin/test/OngoingStubbingTest.kt b/tests/src/test/kotlin/test/OngoingStubbingTest.kt
index 28917202..cd981bc5 100644
--- a/tests/src/test/kotlin/test/OngoingStubbingTest.kt
+++ b/tests/src/test/kotlin/test/OngoingStubbingTest.kt
@@ -2,7 +2,9 @@ package test
 
 import com.nhaarman.expect.expect
 import com.nhaarman.expect.expectErrorWithMessage
-import com.nhaarman.expect.fail
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
 import org.junit.Assume.assumeFalse
 import org.junit.Test
 import org.mockito.Mockito
@@ -13,21 +15,19 @@ import org.mockito.kotlin.check
 import org.mockito.kotlin.doAnswer
 import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.doReturnConsecutively
+import org.mockito.kotlin.doSuspendableAnswer
 import org.mockito.kotlin.doThrow
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.stub
-import org.mockito.kotlin.stubbing
 import org.mockito.kotlin.whenever
 import org.mockito.stubbing.Answer
 
 class OngoingStubbingTest : TestBase() {
-
     @Test
-    fun testOngoingStubbing_methodCall() {
+    fun `should mock methodCall`() {
         /* Given */
-        val mock = mock<Open>()
-        mock<Open> {
-            on(mock.stringResult()).doReturn("A")
+        val mock = mock<Open> {
+            on { stringResult() } doReturn "A"
         }
 
         /* When */
@@ -38,9 +38,67 @@ class OngoingStubbingTest : TestBase() {
     }
 
     @Test
-    fun testOngoingStubbing_builder() {
+    fun `should mock consecutive methodCalls`() {
         /* Given */
-        val mock = mock<Methods> { mock ->
+        val mock = mock<Open> {
+            on { stringResult() }.doReturn ("A", "B", "C")
+        }
+
+        /* When */
+        val result =(1..3).map { _ ->
+            mock.stringResult()
+        }
+
+        /* Then */
+        expect(result).toBe(listOf("A", "B", "C"))
+    }
+
+    @Test
+    fun `should mock consecutive methodCalls by a list of answers`() {
+        /* Given */
+        val mock = mock<Open> {
+            on { stringResult() } doReturnConsecutively listOf("A", "B", "C")
+        }
+
+        /* When */
+        val result =(1..3).map { _ ->
+            mock.stringResult()
+        }
+
+        /* Then */
+        expect(result).toBe(listOf("A", "B", "C"))
+    }
+
+    @Test
+    fun `should mock builder method returning mock itself via defaultAnswer`() {
+        /* Given */
+        val mock = mock<SynchronousFunctions>(defaultAnswer = Mockito.RETURNS_SELF)
+
+        /* When */
+        val result = mock.builderMethod()
+
+        /* Then */
+        expect(result).toBeTheSameAs(mock)
+    }
+
+    @Test
+    fun `should mock builder method returning mock itself via answer`() {
+        /* Given */
+        val mock = mock<SynchronousFunctions> {
+            on { builderMethod() } doAnswer Mockito.RETURNS_SELF
+        }
+
+        /* When */
+        val result = mock.builderMethod()
+
+        /* Then */
+        expect(result).toBeTheSameAs(mock)
+    }
+
+    @Test
+    fun `should mock builder method returning mock itself`() {
+        /* Given */
+        val mock = mock<SynchronousFunctions> { mock ->
             on { builderMethod() } doReturn mock
         }
 
@@ -52,9 +110,9 @@ class OngoingStubbingTest : TestBase() {
     }
 
     @Test
-    fun testOngoingStubbing_nullable() {
+    fun `should mock methodCall with nullable result`() {
         /* Given */
-        val mock = mock<Methods> {
+        val mock = mock<SynchronousFunctions> {
             on { nullableStringResult() } doReturn "Test"
         }
 
@@ -66,90 +124,76 @@ class OngoingStubbingTest : TestBase() {
     }
 
     @Test
-    fun testOngoingStubbing_doThrow() {
+    fun `should throw exception instance on methodCall`() {
         /* Given */
-        val mock = mock<Methods> {
+        val mock = mock<SynchronousFunctions> {
             on { builderMethod() } doThrow IllegalArgumentException()
         }
 
-        try {
-            /* When */
+        /* When, Then */
+        assertThrows<IllegalArgumentException> {
             mock.builderMethod()
-            fail("No exception thrown")
-        } catch (e: IllegalArgumentException) {
         }
     }
 
     @Test
-    fun testOngoingStubbing_doThrowClass() {
+    fun `should throw exception class on methodCall`() {
         /* Given */
-        val mock = mock<Methods> {
+        val mock = mock<SynchronousFunctions> {
             on { builderMethod() } doThrow IllegalArgumentException::class
         }
 
-        try {
-            /* When */
+        /* When, Then */
+        assertThrows<IllegalArgumentException> {
             mock.builderMethod()
-            fail("No exception thrown")
-        } catch (e: IllegalArgumentException) {
         }
     }
 
     @Test
-    fun testOngoingStubbing_doThrowVarargs() {
+    fun `should throw exception instances on consecutive methodCalls`() {
         /* Given */
-        val mock = mock<Methods> {
+        val mock = mock<SynchronousFunctions> {
             on { builderMethod() }.doThrow(
                   IllegalArgumentException(),
                   UnsupportedOperationException()
             )
         }
 
-        try {
-            /* When */
+        /* When, Then */
+        assertThrows<IllegalArgumentException> {
             mock.builderMethod()
-            fail("No exception thrown")
-        } catch (e: IllegalArgumentException) {
         }
-
-        try {
-            /* When */
+        assertThrows<UnsupportedOperationException> {
             mock.builderMethod()
-            fail("No exception thrown")
-        } catch (e: UnsupportedOperationException) {
         }
     }
 
     @Test
-    fun testOngoingStubbing_doThrowClassVarargs() {
+    fun `should throw exception classes on consecutive methodCalls`() {
         /* Given */
-        val mock = mock<Methods> {
+        val mock = mock<SynchronousFunctions> {
             on { builderMethod() }.doThrow(
                   IllegalArgumentException::class,
                   UnsupportedOperationException::class
             )
         }
 
-        try {
-            /* When */
+        /* When, Then */
+        assertThrows<IllegalArgumentException> {
             mock.builderMethod()
-            fail("No exception thrown")
-        } catch (e: IllegalArgumentException) {
         }
-
-        try {
-            /* When */
+        assertThrows<UnsupportedOperationException> {
             mock.builderMethod()
-            fail("No exception thrown")
-        } catch (e: UnsupportedOperationException) {
         }
     }
 
     @Test
-    fun testOngoingStubbing_doAnswer_lambda() {
+    fun `should mock methodCall with result from answer instance`() {
         /* Given */
-        val mock = mock<Methods> {
-            on { stringResult() } doAnswer { "result" }
+        val answer: Answer<String> = Answer { "result" }
+
+        val mock = mock<SynchronousFunctions> {
+            on { stringResult() } doAnswer answer
         }
 
         /* When */
@@ -160,10 +204,10 @@ class OngoingStubbingTest : TestBase() {
     }
 
     @Test
-    fun testOngoingStubbing_doAnswer_instance() {
+    fun `should mock methodCall with result from lambda`() {
         /* Given */
-        val mock = mock<Methods> {
-            on { stringResult() } doAnswer Answer<String> { "result" }
+        val mock = mock<SynchronousFunctions> {
+            on { stringResult() } doAnswer { "result" }
         }
 
         /* When */
@@ -174,23 +218,9 @@ class OngoingStubbingTest : TestBase() {
     }
 
     @Test
-    fun testOngoingStubbing_doAnswer_returnsSelf() {
+    fun `should mock methodCall with result from lambda with argument`() {
         /* Given */
-        val mock = mock<Methods> {
-            on { builderMethod() } doAnswer Mockito.RETURNS_SELF
-        }
-
-        /* When */
-        val result = mock.builderMethod()
-
-        /* Then */
-        expect(result).toBe(mock)
-    }
-
-    @Test
-    fun testOngoingStubbing_doAnswer_withArgument() {
-        /* Given */
-        val mock = mock<Methods> {
+        val mock = mock<SynchronousFunctions> {
             on { stringResult(any()) } doAnswer { "${it.arguments[0]}-result" }
         }
 
@@ -202,9 +232,9 @@ class OngoingStubbingTest : TestBase() {
     }
 
     @Test
-    fun testOngoingStubbing_doAnswer_withDestructuredArgument() {
+    fun `should mock methodCall with result from lambda with deconstructed argument`() {
         /* Given */
-        val mock = mock<Methods> {
+        val mock = mock<SynchronousFunctions> {
             on { stringResult(any()) } doAnswer { (s: String) -> "$s-result" }
         }
 
@@ -216,9 +246,9 @@ class OngoingStubbingTest : TestBase() {
     }
 
     @Test
-    fun testOngoingStubbing_doAnswer_withDestructuredArguments() {
+    fun `should mock methodCall with result from lambda with deconstructed arguments`() {
         /* Given */
-        val mock = mock<Methods> {
+        val mock = mock<SynchronousFunctions> {
             on { varargBooleanResult(any(), any()) } doAnswer { (a: String, b: String) ->
                 a == b.trim()
             }
@@ -232,8 +262,8 @@ class OngoingStubbingTest : TestBase() {
     }
 
     @Test
-    fun testMockStubbingAfterCreatingMock() {
-        val mock = mock<Methods>()
+    fun `should stub already created mock`() {
+        val mock = mock<SynchronousFunctions>()
 
         //create stub after creation of mock
         mock.stub {
@@ -248,9 +278,9 @@ class OngoingStubbingTest : TestBase() {
     }
 
     @Test
-    fun testOverrideDefaultStub() {
+    fun `should override stub of already created mock`() {
         /* Given mock with stub */
-        val mock = mock<Methods> {
+        val mock = mock<SynchronousFunctions> {
             on { stringResult() } doReturn "result1"
         }
 
@@ -267,9 +297,9 @@ class OngoingStubbingTest : TestBase() {
     }
 
     @Test
-    fun stubbingTwiceWithArgumentMatchers() {
+    fun `should stub 2 method calls determined by ArgumentMatchers`() {
         /* When */
-        val mock = mock<Methods> {
+        val mock = mock<SynchronousFunctions> {
             on { stringResult(argThat { this == "A" }) } doReturn "A"
             on { stringResult(argThat { this == "B" }) } doReturn "B"
         }
@@ -280,97 +310,142 @@ class OngoingStubbingTest : TestBase() {
     }
 
     @Test
-    fun stubbingRealObject() {
-        val notAMock = ""
-
-        /* Expect */
-        expectErrorWithMessage("is not a mock!").on {
-            notAMock.stub { }
-        }
-    }
-
-    @Test
-    fun stubbingTwiceWithCheckArgumentMatchers_throwsException() {
-        /* Expect */
-        expectErrorWithMessage("null").on {
-            mock<Methods> {
+    // stubbingTwiceWithCheckArgumentMatchers_throwsException
+    fun `should throw when check ArgumentMatcher is applied twice`() {
+        val exception: IllegalStateException = assertThrows {
+            mock<SynchronousFunctions> {
                 on { stringResult(check { }) } doReturn "A"
                 on { stringResult(check { }) } doReturn "B"
             }
         }
+        expect(exception.message).toContain("The argument passed to the predicate was null")
     }
 
     @Test
-    fun doReturn_withSingleItemList() {
+    fun `should mock methodCall with integer result`() {
         /* Given */
-        val mock = mock<Open> {
-            on { stringResult() } doReturnConsecutively listOf("a", "b")
+        val mock = mock<GenericMethods<Int>> {
+            onGeneric { genericMethod() } doReturn 2
         }
 
         /* Then */
-        expect(mock.stringResult()).toBe("a")
-        expect(mock.stringResult()).toBe("b")
+        expect(mock.genericMethod()).toBe(2)
     }
 
     @Test
-    fun doReturn_throwsNPE() {
-        assumeFalse(mockMakerInlineEnabled())
-        expectErrorWithMessage("look at the stack trace below") on {
-
-            /* When */
-            mock<Open> {
-                on { throwsNPE() } doReturn "result"
-            }
+    fun `should mock nullable methodCall with string result`() {
+        val mock = mock<GenericMethods<String>> {
+            onGeneric { nullableReturnType() } doReturn "Test"
         }
+
+        expect(mock.nullableReturnType()).toBe("Test")
     }
 
     @Test
-    fun doReturn_withGenericIntReturnType_onGeneric() {
+    fun `should mock methodCall with value class result`() {
         /* Given */
-        val mock = mock<GenericMethods<Int>> {
-            onGeneric { genericMethod() } doReturn 2
+        val valueClass = ValueClass("A")
+        val mock = mock<SynchronousFunctions> {
+            on { valueClassResult() } doReturn valueClass
         }
 
+        /* When */
+        val result: ValueClass = mock.valueClassResult()
+
         /* Then */
-        expect(mock.genericMethod()).toBe(2)
+        expect(result).toBe(valueClass)
     }
 
     @Test
-    fun doReturn_withGenericNullableReturnType_onGeneric() {
-        val m = mock<GenericMethods<String>> {
-            onGeneric { nullableReturnType() } doReturn "Test"
+    fun `should mock methodCall with nullable value class result`() {
+        /* Given */
+        val valueClass = ValueClass("A")
+        val mock = mock<SynchronousFunctions> {
+            on { nullableValueClassResult() } doReturn valueClass
         }
 
-        expect(m.nullableReturnType()).toBe("Test")
+        /* When */
+        val result: ValueClass? = mock.nullableValueClassResult()
+
+        /* Then */
+        expect(result).toBe(valueClass)
     }
 
     @Test
-    fun stubbingExistingMock() {
+    fun `should mock methodCall with nested value class result`() {
         /* Given */
-        val mock = mock<Methods>()
+        val nestedValueClass = NestedValueClass(ValueClass("A"))
+        val mock = mock<SynchronousFunctions> {
+            on { nestedValueClassResult() } doReturn nestedValueClass
+        }
 
         /* When */
-        stubbing(mock) {
-            on { stringResult() } doReturn "result"
+        val result: NestedValueClass = mock.nestedValueClassResult()
+
+        /* Then */
+        expect(result).toBe(nestedValueClass)
+        expect(result.value).toBe(nestedValueClass.value)
+    }
+
+    @Test
+    fun `should mock consecutive methodCall with value class results`() {
+        /* Given */
+        val valueClassA = ValueClass("A")
+        val valueClassB = ValueClass("B")
+        val mock = mock<SynchronousFunctions> {
+            on { valueClassResult() }.doReturnConsecutively(valueClassA, valueClassB)
         }
 
+        /* When */
+        val result1 = mock.valueClassResult()
+        val result2 = mock.valueClassResult()
+
         /* Then */
-        expect(mock.stringResult()).toBe("result")
+        expect(result1).toBe(valueClassA)
+        expect(result2).toBe(valueClassB)
     }
 
     @Test
-    fun testMockitoStackOnUnfinishedStubbing() {
+    fun `should mock suspendable methodCall with value class result -- deprecated approach`() =
+        runTest {
+            /* Given */
+            val valueClass = ValueClass("A")
+            val mock = mock<SuspendFunctions> {
+                on(mock.valueClassResult()) doSuspendableAnswer {
+                    delay(1)
+                    valueClass
+                }
+            }
+
+            /* When */
+            val result: ValueClass = mock.valueClassResult()
+
+            /* Then */
+            expect(result).toBe(valueClass)
+        }
+
+    @Test
+    fun `should throw when stubbing is incomplete`() {
         /* Given */
         val mock = mock<Open>()
         whenever(mock.stringResult())
 
         /* When */
-        try {
+        val exception = assertThrows<UnfinishedStubbingException> {
             mock.stringResult()
-        } catch (e: UnfinishedStubbingException) {
-            /* Then */
-            expect(e.message).toContain("Unfinished stubbing detected here:")
-            expect(e.message).toContain("-> at test.OngoingStubbingTest.testMockitoStackOnUnfinishedStubbing")
+        }
+        expect(exception.message).toContain("Unfinished stubbing detected here:")
+    }
+
+    @Test
+    fun doReturn_throwsNPE() {
+        assumeFalse("mockMakerInline is not enabled", mockMakerInlineEnabled())
+        expectErrorWithMessage("look at the stack trace below") on {
+
+            /* When */
+            mock<Open> {
+                on { throwsNPE() } doReturn "result"
+            }
         }
     }
 }
diff --git a/tests/src/test/kotlin/test/StubberTest.kt b/tests/src/test/kotlin/test/StubberTest.kt
index 7b8f6af9..5144cb7e 100644
--- a/tests/src/test/kotlin/test/StubberTest.kt
+++ b/tests/src/test/kotlin/test/StubberTest.kt
@@ -9,7 +9,7 @@ class StubberTest : TestBase() {
 
     @Test
     fun testDoAnswer() {
-        val mock = mock<Methods>()
+        val mock = mock<SynchronousFunctions>()
 
         doAnswer { "Test" }
             .whenever(mock)
@@ -41,7 +41,7 @@ class StubberTest : TestBase() {
 
     @Test
     fun testDoReturnValue() {
-        val mock = mock<Methods>()
+        val mock = mock<SynchronousFunctions>()
 
         doReturn("test").whenever(mock).stringResult()
 
@@ -50,7 +50,7 @@ class StubberTest : TestBase() {
 
     @Test
     fun testDoReturnNullValue() {
-        val mock = mock<Methods>()
+        val mock = mock<SynchronousFunctions>()
 
         doReturn(null).whenever(mock).stringResult()
 
@@ -59,7 +59,7 @@ class StubberTest : TestBase() {
 
     @Test
     fun testDoReturnNullValues() {
-        val mock = mock<Methods>()
+        val mock = mock<SynchronousFunctions>()
 
         doReturn(null, null).whenever(mock).stringResult()
 
@@ -69,7 +69,7 @@ class StubberTest : TestBase() {
 
     @Test
     fun testDoReturnValues() {
-        val mock = mock<Methods>()
+        val mock = mock<SynchronousFunctions>()
 
         doReturn("test", "test2").whenever(mock).stringResult()
 
@@ -86,7 +86,7 @@ class StubberTest : TestBase() {
         try {
             mock.go()
             throw AssertionError("Call should have thrown.")
-        } catch (e: IllegalStateException) {
+        } catch (_: IllegalStateException) {
         }
     }
 
@@ -103,7 +103,7 @@ class StubberTest : TestBase() {
 
     @Test
     fun testStubberOnBlockExtension() {
-        val mock = mock<Methods> {
+        val mock = mock<SynchronousFunctions> {
             doReturn("Test").on { stringResult() }
         }
 
diff --git a/tests/src/test/kotlin/test/StubbingTest.kt b/tests/src/test/kotlin/test/StubbingTest.kt
new file mode 100644
index 00000000..1b22fb6e
--- /dev/null
+++ b/tests/src/test/kotlin/test/StubbingTest.kt
@@ -0,0 +1,261 @@
+package test
+
+import com.nhaarman.expect.expect
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+import org.mockito.exceptions.misusing.NotAMockException
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.doSuspendableAnswer
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.onBlocking
+import org.mockito.kotlin.stub
+import org.mockito.kotlin.stubbing
+import org.mockito.kotlin.whenever
+import org.mockito.kotlin.wheneverBlocking
+
+
+class StubbingTest {
+    @Test
+    fun `should stub sync method call as part of mock creation`() {
+        /* Given */
+        val mock = mock<Open> {
+            on { stringResult() } doReturn "A"
+        }
+
+        /* When */
+        val result = mock.stringResult()
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+
+    @Test
+    fun `should stub sync method call in reverse manner as part of mock creation`() {
+        val mock = mock<SynchronousFunctions> {
+            doReturn("A").on { stringResult() }
+        }
+
+        expect(mock.stringResult()).toBe("A")
+    }
+
+    @Test
+    fun `should stub sync method call with whenever`() {
+        /* Given */
+        val mock = mock<Open>()
+        whenever(mock.stringResult()).doReturn("A")
+
+        /* When */
+        val result = mock.stringResult()
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+
+    @Test
+    fun `should stub sync method call with whenever and lambda`() {
+        /* Given */
+        val mock = mock<Open>()
+        whenever { mock.stringResult() } doReturn "A"
+
+        /* When */
+        val result = mock.stringResult()
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+
+    @Test
+    fun `should stub sync method call with reverse whenever`() {
+        /* Given */
+        val mock = mock<Open>()
+        doReturn("A").whenever(mock).stringResult()
+
+        /* When */
+        val result = mock.stringResult()
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+
+    @Test
+    fun `should stub sync method call using stub extension method`() {
+        /* Given */
+        val mock = mock<Open>()
+        mock.stub{
+            on { stringResult() } doReturn "A"
+        }
+
+        /* When */
+        val result = mock.stringResult()
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+
+    @Test
+    fun `should stub sync method call using stubbing method`() {
+        /* Given */
+        val mock = mock<Open>()
+        stubbing(mock) {
+            on { stringResult() } doReturn "A"
+        }
+
+        /* When */
+        val result = mock.stringResult()
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+
+    @Test
+    fun `should stub suspendable function call with wheneverBlocking as part of mock creation`() {
+        /* Given */
+        val mock = mock<SuspendFunctions> { mock ->
+            wheneverBlocking { mock.stringResult() } doReturn "A"
+        }
+
+        /* When */
+        val result = runBlocking { mock.stringResult() }
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+
+    @Test
+    fun `should stub suspendable function call in reverse manner with wheneverBlocking as part of mock creation`() {
+        /* Given */
+        val mock = mock<SuspendFunctions> { mock ->
+            doReturn( "A").wheneverBlocking(mock) { mock.stringResult() }
+        }
+
+        /* When */
+        val result = runBlocking { mock.stringResult() }
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+
+    @Test
+    fun `should stub suspendable function call in reverse manner with onBlocking as part of mock creation`() {
+        /* Given */
+        val mock = mock<SuspendFunctions> { mock ->
+            doReturn( "A").onBlocking(mock) { mock.stringResult() }
+        }
+
+        /* When */
+        val result = runBlocking { mock.stringResult() }
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+
+    @Test
+    fun `should stub suspendable function call in reverse manner with whenever as part of mock creation`() = runTest{
+        /* Given */
+        val mock = mock<SuspendFunctions> { mock ->
+            doReturn( "A").whenever(mock).stringResult()
+        }
+
+        /* When */
+        val result = runBlocking { mock.stringResult() }
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+
+    @Test
+    fun `should stub sync function call within a suspendable lambda`() {
+        /* Given */
+        val mock = mock<SynchronousFunctions> {
+            onBlocking { stringResult() } doReturn "A"
+        }
+
+        /* When */
+        val result = mock.stringResult()
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+
+    @Test
+    fun `should stub sync function call within a suspendable lambda of wheneverBlocking`() {
+        /* Given */
+        val mock = mock<SynchronousFunctions>()
+        wheneverBlocking { mock.stringResult() } doReturn "A"
+
+        /* When */
+        val result = mock.stringResult()
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+
+    @Test
+    fun `should stub suspend function call with a call to the sync version of whenever`() = runTest {
+        /* Given */
+        val mock = mock<SuspendFunctions>()
+        whenever (mock.stringResult()) doReturn "A"
+
+        /* When */
+        val result = mock.stringResult()
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+
+    @Test
+    fun `should throw when stubbing other mock then being created`() {
+        /* Given */
+        val mock = mock<Open>()
+
+        /* When, Then */
+        val exception: IllegalArgumentException = assertThrows {
+            mock<Open> {
+                on(mock.stringResult()).doReturn("A")
+            }
+        }
+        expect(exception.message).toContain("Stubbing of another mock is not allowed")
+    }
+
+    @Test
+    fun `should throw when trying to stub a real object with stub extension method`() {
+        /* Given */
+        val notAMock = Open()
+
+        /* When, Then */
+        val exception: NotAMockException = assertThrows {
+            notAMock.stub {  }
+        }
+        expect(exception.message).toContain("Stubbing target is not a mock!")
+    }
+
+    @Test
+    fun `should throw when trying to stub a real object with stubbing method`() {
+        /* Given */
+        val notAMock = Open()
+
+        /* When, Then */
+        val exception: NotAMockException = assertThrows {
+            stubbing(notAMock) {  }
+        }
+        expect(exception.message).toContain("Stubbing target is not a mock!")
+    }
+
+    @Test
+    fun `should provide backwards support to stub suspendable function call with 'whenever' method`() = runTest {
+        /* Given */
+        val mock = mock<SuspendFunctions>()
+        whenever(mock.stringResult()).doSuspendableAnswer {
+            delay(0)
+            "A"
+        }
+
+        /* When */
+        val result = runBlocking { mock.stringResult() }
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+}
diff --git a/tests/src/test/kotlin/test/VerificationTest.kt b/tests/src/test/kotlin/test/VerificationTest.kt
index db5620fc..62acb0c8 100644
--- a/tests/src/test/kotlin/test/VerificationTest.kt
+++ b/tests/src/test/kotlin/test/VerificationTest.kt
@@ -10,7 +10,7 @@ class VerificationTest : TestBase() {
 
     @Test
     fun atLeastXInvocations() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             string("")
             string("")
 
@@ -20,7 +20,7 @@ class VerificationTest : TestBase() {
 
     @Test
     fun testAtLeastOnce() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             string("")
             string("")
 
@@ -30,7 +30,7 @@ class VerificationTest : TestBase() {
 
     @Test
     fun atMostXInvocations() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             string("")
             string("")
 
@@ -40,7 +40,7 @@ class VerificationTest : TestBase() {
 
     @Test
     fun testCalls() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             string("")
             string("")
 
@@ -68,7 +68,7 @@ class VerificationTest : TestBase() {
     @Test
     fun testInOrderWithReceiver() {
         /* Given */
-        val mock = mock<Methods>()
+        val mock = mock<SynchronousFunctions>()
 
         /* When */
         mock.string("")
@@ -84,7 +84,7 @@ class VerificationTest : TestBase() {
 
     @Test
     fun testClearInvocations() {
-        val mock = mock<Methods>().apply {
+        val mock = mock<SynchronousFunctions>().apply {
             string("")
         }
 
@@ -96,7 +96,7 @@ class VerificationTest : TestBase() {
     @Test
     fun testDescription() {
         try {
-            mock<Methods>().apply {
+            mock<SynchronousFunctions>().apply {
                 verify(this, description("Test")).string(any())
             }
             throw AssertionError("Verify should throw Exception.")
@@ -107,7 +107,7 @@ class VerificationTest : TestBase() {
 
     @Test
     fun testAfter() {
-        mock<Methods>().apply {
+        mock<SynchronousFunctions>().apply {
             int(3)
             verify(this, after(10)).int(3)
         }