Solve 6.2.0 regression due to runblocking being unavailable

build.gradle

@@ -9,7 +9,7 @@ plugins {
 }
 
 def test = tasks.register("test") {
-    dependsOn gradle.includedBuild("tests").task(":test")
+    dependsOn gradle.includedBuild("tests").task(":test"), gradle.includedBuild("no-coroutine-tests").task(":test")
 }
 tasks.named("check") {
     dependsOn test

mockito-kotlin/src/main/kotlin/org/mockito/kotlin/KStubbing.kt

@@ -31,6 +31,7 @@ import org.mockito.Mockito
 import org.mockito.Mockito.`when`
 import org.mockito.exceptions.misusing.NotAMockException
 import org.mockito.kotlin.internal.createInstance
+import org.mockito.kotlin.internal.safeRunBlocking
 import org.mockito.stubbing.OngoingStubbing
 import org.mockito.stubbing.Stubber
 
@@ -143,7 +144,7 @@ class KStubbing<out T : Any>(val mock: T) {
     fun <R : Any> onGeneric(methodCall: suspend T.() -> R?, clazz: KClass<R>): OngoingStubbing<R> {
         val r =
             try {
-                runBlocking { mock.methodCall() }
+                safeRunBlocking { mock.methodCall() }
             } catch (_: NullPointerException) {
                 // An NPE may be thrown by the Kotlin type system when the MockMethodInterceptor
                 // returns a

mockito-kotlin/src/main/kotlin/org/mockito/kotlin/OngoingStubbing.kt

@@ -37,6 +37,7 @@ import org.mockito.internal.stubbing.answers.ThrowsExceptionForClassType
 import org.mockito.kotlin.internal.CoroutineAwareAnswer
 import org.mockito.kotlin.internal.CoroutineAwareAnswer.Companion.wrapAsCoroutineAwareAnswer
 import org.mockito.kotlin.internal.KAnswer
+import org.mockito.kotlin.internal.safeRunBlocking
 import org.mockito.stubbing.Answer
 import org.mockito.stubbing.OngoingStubbing
 
@@ -92,8 +93,8 @@ fun <T> whenever(methodCall: T): OngoingStubbing<T> {
  * @return OngoingStubbing object used to stub fluently. ***Do not*** create a reference to this
  *   returned object.
  */
-fun <T> whenever(methodCall: suspend CoroutineScope.() -> T): OngoingStubbing<T> {
-    return runBlocking { `when`<T>(methodCall())!! }
+fun <T> whenever(methodCall: suspend () -> T): OngoingStubbing<T> {
+    return safeRunBlocking { `when`<T>(methodCall()) }
 }
 
 /**
@@ -108,7 +109,7 @@ fun <T> whenever(methodCall: suspend CoroutineScope.() -> T): OngoingStubbing<T>
  */
 @Deprecated("Use whenever { mock.methodCall() } instead")
 fun <T> wheneverBlocking(methodCall: suspend CoroutineScope.() -> T): OngoingStubbing<T> {
-    return whenever(methodCall)
+    return runBlocking { `when`(methodCall()) }
 }
 
 /**

mockito-kotlin/src/main/kotlin/org/mockito/kotlin/Stubber.kt

@@ -26,12 +26,16 @@
 package org.mockito.kotlin
 
 import kotlin.reflect.KClass
-import kotlinx.coroutines.runBlocking
 import org.mockito.Mockito
-import org.mockito.internal.stubbing.answers.*
+import org.mockito.internal.stubbing.answers.CallsRealMethods
+import org.mockito.internal.stubbing.answers.DoesNothing
+import org.mockito.internal.stubbing.answers.Returns
+import org.mockito.internal.stubbing.answers.ThrowsException
+import org.mockito.internal.stubbing.answers.ThrowsExceptionForClassType
 import org.mockito.kotlin.internal.CoroutineAwareAnswer
 import org.mockito.kotlin.internal.CoroutineAwareAnswer.Companion.wrapAsCoroutineAwareAnswer
 import org.mockito.kotlin.internal.KAnswer
+import org.mockito.kotlin.internal.safeRunBlocking
 import org.mockito.stubbing.Answer
 import org.mockito.stubbing.Stubber
 
@@ -283,7 +287,7 @@ fun <T> Stubber.whenever(mock: T) = `when`(mock)!!
  *   stubbed.
  */
 fun <T> Stubber.whenever(mock: T, methodCall: suspend T.() -> Unit) {
-    whenever(mock).let { runBlocking { it.methodCall() } }
+    whenever(mock).let { safeRunBlocking { it.methodCall() } }
 }
 
 /**

mockito-kotlin/src/main/kotlin/org/mockito/kotlin/internal/SafeRunBlocking.kt

@@ -0,0 +1,90 @@
+/*
+ * 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 kotlin.coroutines.Continuation
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.startCoroutine
+import kotlinx.coroutines.runBlocking
+import org.mockito.kotlin.mock
+
+internal fun <T> safeRunBlocking(block: suspend () -> T): T {
+    return try {
+        Class.forName("kotlinx.coroutines.BuildersKt")
+        runBlocking { block() }
+    } catch (_: ClassNotFoundException) {
+        bareBasicsRunBlocking(block)
+    }
+}
+
+/**
+ * This function is a bare basics replacement for the proper function runBlocking from the
+ * kotlinx-coroutines-core library.
+ *
+ * Mockito-kotlin is compiled with kotlinx-coroutines-core library on the compileOnly classpath, so
+ * the library is not marked as a transitive dependency of Mockito-kotlin.
+ *
+ * Mockito-kotlin API, like [org.mockito.kotlin.whenever] accepts suspending lambda arguments to
+ * unify the handling of synchronous and suspending lambdas. Currently, Kotlin compiler does not yet
+ * allow to define overload functions, one for a synchronous lambda and one for a suspending lambda:
+ * it leads to resolution ambiguity issues. But once a synchronous lambda is passed into the
+ * Mockito-kotlin API and then flagged as potentially suspending, there is no easy way to unflag the
+ * suspending nature.
+ *
+ * If the project that applies Mockito-kotlin is not including the kotlinx-coroutines-core
+ * dependency, simply because the project does not include any suspending/coroutines functionality,
+ * Mockito-kotlin needs an alternative mean to execute the lambda parameter flagged as suspending.
+ *
+ * Therefor this function assumes that the lambda parameter [block], although marked suspending,
+ * should be considered a synchronous lambda in the absence of any coroutines infrastructure as
+ * delivered by the kotlinx-coroutines-core library. It takes a bare basics approach to invoke the
+ * lambda on the current thread without any safeguards for (potential) suspension points in the
+ * lambda.
+ *
+ * In future, when support for overloads just differing in suspending nature of the lambda argument
+ * is provided by the Kotlin compiler, this rather ugly fix should be dropped in favor of
+ * introducing proper overloads in the Mockito-kotlin API to cater for both synchronous and
+ * suspending lambdas.
+ */
+private fun <T> bareBasicsRunBlocking(block: suspend () -> T): T {
+    val completion = SimpleContinuation<T>()
+    block.startCoroutine(completion)
+    return completion.result!!.let { result ->
+        result.exceptionOrNull()?.let { throw it }
+        result.getOrNull()!!
+    }
+}
+
+private class SimpleContinuation<T> : Continuation<T> {
+    var result: Result<T>? = null
+
+    override val context: CoroutineContext
+        get() = mock()
+
+    override fun resumeWith(result: Result<T>) {
+        this.result = result
+    }
+}

no-coroutine-tests/build.gradle

@@ -0,0 +1,24 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    id "org.gradle.java"
+    id "org.jetbrains.kotlin.jvm" version "2.1.20"
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation "org.mockito.kotlin:mockito-kotlin"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib"
+    testImplementation 'junit:junit:4.13.2'
+}
+
+tasks.withType(KotlinCompile).configureEach {
+    compilerOptions {
+        jvmTarget.set(JvmTarget.JVM_11)
+        targetCompatibility = "11"
+    }
+}

no-coroutine-tests/settings.gradle

@@ -0,0 +1 @@
+includeBuild '..'

no-coroutine-tests/src/test/kotlin/RegressionTest.kt

@@ -0,0 +1,22 @@
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.stubbing
+
+class RegressionTest {
+    private val a = mock<A>()
+
+    @Test
+    fun `should stub synchronous mock in absence of the 'kotlinx-coroutines-core' library`() {
+        stubbing(a) {
+            on { doSomething() }
+                .thenReturn("a")
+        }
+
+        assertEquals("a", a.doSomething())
+    }
+}
+
+interface A {
+    fun doSomething(): String
+}

settings.gradle

@@ -6,3 +6,4 @@ rootProject.name = 'mockito-kotlin-root'
 
 include 'mockito-kotlin'
 includeBuild 'tests'
+includeBuild 'no-coroutine-tests'