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

@@ -42,6 +42,9 @@ 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()
 }
 
@@ -71,6 +74,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,17 @@ interface Methods {
     fun argAndVararg(s: String, vararg a: String)
 
     fun nonDefaultReturnType(): ExtraInterface
+
+    fun valueClass(v: ValueClass?)
+    fun nestedValueClass(v: NestedValueClass)
 }
 
+@JvmInline
+value class ValueClass(private val content: String)
+
+@JvmInline
+value class NestedValueClass(val value: ValueClass)
+
 interface ExtraInterface
 
 abstract class ThrowingConstructor {

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

@@ -319,6 +319,57 @@ class MatchersTest : TestBase() {
         }
     }
 
+    @Test
+    fun any_forValueClass() {
+        mock<Methods>().apply {
+            valueClass(ValueClass("Content"))
+            verify(this).valueClass(any())
+        }
+    }
+
+    @Test
+    fun anyOrNull_forValueClass() {
+        mock<Methods>().apply {
+            valueClass(ValueClass("Content"))
+            verify(this).valueClass(anyOrNull())
+        }
+    }
+
+    @Test
+    fun anyOrNull_forValueClass_withNull() {
+        mock<Methods>().apply {
+            valueClass(null)
+            verify(this).valueClass(anyOrNull())
+        }
+    }
+
+    @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)
+                // Should throw an error because Float is not a value class
+                float(anyValueClass())
+            }
+        }
+    }
+
+    @Test
+    fun anyValueClass_withNestedValueClass() {
+        mock<Methods>().apply {
+            nestedValueClass(NestedValueClass(ValueClass("Content")))
+            verify(this).nestedValueClass(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.