Added value class support

mockito-kotlin/build.gradle

@@ -16,6 +16,7 @@ repositories {
 dependencies {
     compileOnly "org.jetbrains.kotlin:kotlin-stdlib"
     compileOnly 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.0.0'
+    implementation "org.jetbrains.kotlin:kotlin-reflect:1.9.20"
 
     api "org.mockito:mockito-core:5.7.0"
 

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

@@ -29,6 +29,7 @@ import org.mockito.ArgumentMatcher
 import org.mockito.ArgumentMatchers
 import org.mockito.kotlin.internal.createInstance
 import kotlin.reflect.KClass
+import kotlin.reflect.jvm.internal.impl.load.kotlin.JvmType.Object
 
 /** Object argument that is equal to the given value. */
 fun <T> eq(value: T): T {
@@ -42,11 +43,17 @@ fun <T> same(value: T): T {
 
 /** Matches any object, excluding nulls. */
 inline fun <reified T : Any> any(): T {
+    if(T::class.isValue)
+        return anyValueClass()
+
     return ArgumentMatchers.any(T::class.java) ?: createInstance()
 }
 
 /** Matches anything, including nulls. */
 inline fun <reified T : Any> anyOrNull(): T {
+    if(T::class.isValue)
+        return anyValueClass()
+
     return ArgumentMatchers.any<T>() ?: createInstance()
 }
 
@@ -71,6 +78,21 @@ inline fun <reified T : Any?> anyArray(): Array<T> {
     return ArgumentMatchers.any(Array<T>::class.java) ?: arrayOf()
 }
 
+/** Matches any Kotlin value class with the same boxed type by taking its boxed type. */
+inline fun <reified T > anyValueClass(): T {
+    require(T::class.isValue) {
+        "${T::class.qualifiedName} is not a value class."
+    }
+
+    val boxImpls = T::class.java.declaredMethods.filter { it.name == "box-impl" && it.parameterCount == 1 }
+    require(boxImpls.size == 1) // Sanity check
+
+    val boxImpl = boxImpls.first()
+    val boxedType = boxImpl.parameters[0].type
+
+    return boxImpl.invoke(null, ArgumentMatchers.any(boxedType)) as T
+}
+
 /**
  * Creates a custom argument matcher.
  * `null` values will never evaluate to `true`.

tests/src/test/kotlin/test/Classes.kt

@@ -81,8 +81,13 @@ interface Methods {
     fun argAndVararg(s: String, vararg a: String)
 
     fun nonDefaultReturnType(): ExtraInterface
+
+    fun valueClass(v: ValueClass)
 }
 
+@JvmInline
+value class ValueClass(private val content: String)
+
 interface ExtraInterface
 
 abstract class ThrowingConstructor {

tests/src/test/kotlin/test/MatchersTest.kt

@@ -319,6 +319,32 @@ class MatchersTest : TestBase() {
         }
     }
 
+    @Test
+    fun any_forValueClass() {
+        mock<Methods>().apply {
+            valueClass(ValueClass("Content"))
+            verify(this).valueClass(any())
+        }
+    }
+
+    @Test
+    fun anyValueClass_withValueClass() {
+        mock<Methods>().apply {
+            valueClass(ValueClass("Content"))
+            verify(this).valueClass(anyValueClass())
+        }
+    }
+
+    @Test
+    fun anyValueClass_withNonValueClass() {
+        expectErrorWithMessage("kotlin.Float is not a value class.") on {
+            mock<Methods>().apply {
+                float(10f)
+                verify(this).float(anyValueClass())
+            }
+        }
+    }
+
     /**
      * a VarargMatcher implementation for varargs of type [T] that will answer with type [R] if any of the var args
      * matched. Needs to keep state between matching invocations.