#152 support value classes

agent/jvm/src/main/kotlin/io/mockk/ValueClassSupport.kt

@@ -72,14 +72,3 @@ private fun <T : Any> KClass<T>.isValueClass() = try {
 } catch (_: Throwable) {
     false
 }
-
-/**
- * POLYFILL for kotlin version < 1.5
- * will be shadowed by implementation in kotlin SDK 1.5+
- *
- * @return true if this is an inline class, else false
- */
-private val <T : Any> KClass<T>.isValue: Boolean
-    get() = !isData &&
-            primaryConstructor?.parameters?.size == 1 &&
-            java.declaredMethods.any { it.name == "box-impl" }

dsl/common/src/main/kotlin/io/mockk/API.kt

@@ -3557,11 +3557,13 @@ interface TypedMatcher {
     val argumentType: KClass<*>
 
     fun checkType(arg: Any?): Boolean {
-        if (argumentType.simpleName === null) {
-            return true
+        return when {
+            argumentType.simpleName === null -> true
+            else -> {
+                val unboxedClass = InternalPlatformDsl.unboxClass(argumentType)
+                return unboxedClass.isInstance(arg)
+            }
         }
-
-        return argumentType.isInstance(arg)
     }
 }
 

dsl/common/src/main/kotlin/io/mockk/InternalPlatformDsl.kt

@@ -1,6 +1,7 @@
 package io.mockk
 
 import kotlin.coroutines.Continuation
+import kotlin.reflect.KClass
 
 expect object InternalPlatformDsl {
     fun identityHashCode(obj: Any): Int
@@ -35,6 +36,26 @@ expect object InternalPlatformDsl {
     fun counter(): InternalCounter
 
     fun <T> coroutineCall(lambda: suspend () -> T): CoroutineCall<T>
+
+    /**
+     * Get the [KClass] of the single value that a `value class` contains.
+     *
+     * The result might also be a value class! So check recursively, if necessary.
+     *
+     * @return [KClass] of boxed value, if this is `value class`, else [cls].
+     */
+    fun unboxClass(cls: KClass<*>): KClass<*>
+
+    /**
+     * Normally this simply casts [arg] to `T`
+     *
+     * However, if `T` is a `value class`es (of type [cls]) it will construct a new instance of the
+     * class, and set [arg] as the value.
+     */
+    actual fun <T : Any> boxCast(
+        cls: KClass<*>,
+        arg: Any,
+    ): T
 }
 
 interface CoroutineCall<T> {
@@ -50,4 +71,4 @@ interface InternalCounter {
     val value: Long
 
     fun increment(): Long
-}
+}

dsl/common/src/main/kotlin/io/mockk/Matchers.kt

@@ -140,17 +140,16 @@ data class CaptureNullableMatcher<T : Any>(
  */
 data class CapturingSlotMatcher<T : Any>(
     val captureSlot: CapturingSlot<T>,
-    override val argumentType: KClass<*>
+    override val argumentType: KClass<*>,
 ) : Matcher<T>, CapturingMatcher, TypedMatcher, EquivalentMatcher {
     override fun equivalent(): Matcher<Any> = ConstantMatcher<Any>(true)
 
-    @Suppress("UNCHECKED_CAST")
     override fun capture(arg: Any?) {
         if (arg == null) {
             captureSlot.isNull = true
         } else {
             captureSlot.isNull = false
-            captureSlot.captured = arg as T
+            captureSlot.captured = InternalPlatformDsl.boxCast(argumentType, arg)
         }
         captureSlot.isCaptured = true
     }
@@ -473,4 +472,3 @@ fun CompositeMatcher<*>.captureSubMatchers(arg: Any?) {
             .forEach { it.capture(arg) }
     }
 }
-

dsl/jvm/src/main/kotlin/io/mockk/InternalPlatformDsl.kt

@@ -1,6 +1,5 @@
 package io.mockk
 
-import kotlinx.coroutines.runBlocking
 import java.lang.reflect.AccessibleObject
 import java.lang.reflect.InvocationTargetException
 import java.lang.reflect.Method
@@ -13,10 +12,13 @@ import kotlin.reflect.KProperty1
 import kotlin.reflect.KType
 import kotlin.reflect.KTypeParameter
 import kotlin.reflect.full.allSuperclasses
+import kotlin.reflect.full.declaredMemberProperties
 import kotlin.reflect.full.functions
 import kotlin.reflect.full.memberProperties
+import kotlin.reflect.full.primaryConstructor
 import kotlin.reflect.jvm.isAccessible
 import kotlin.reflect.jvm.javaMethod
+import kotlinx.coroutines.runBlocking
 
 actual object InternalPlatformDsl {
     actual fun identityHashCode(obj: Any): Int = System.identityHashCode(obj)
@@ -214,6 +216,29 @@ actual object InternalPlatformDsl {
     }
 
     actual fun <T> coroutineCall(lambda: suspend () -> T): CoroutineCall<T> = JvmCoroutineCall<T>(lambda)
+
+    actual fun unboxClass(cls: KClass<*>): KClass<*> {
+        if (!cls.isValue) return cls
+
+        // get backing field
+        val backingField = cls.valueField()
+
+        // get boxed value
+        return backingField.returnType.classifier as KClass<*>
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    actual fun <T : Any> boxCast(
+        cls: KClass<*>,
+        arg: Any,
+    ): T {
+        return if (cls.isValue) {
+            val constructor = cls.primaryConstructor!!.apply { isAccessible = true }
+            constructor.call(arg) as T
+        } else {
+            arg as T
+        }
+    }
 }
 
 class JvmCoroutineCall<T>(private val lambda: suspend () -> T) : CoroutineCall<T> {
@@ -232,3 +257,26 @@ class JvmCoroutineCall<T>(private val lambda: suspend () -> T) : CoroutineCall<T
         }
     }
 }
+
+// TODO this is copy-pasted from ValueClassSupport
+//      I will try to move that class so it's available here
+
+private val valueClassFieldCache = mutableMapOf<KClass<out Any>, KProperty1<out Any, *>>()
+
+private fun <T : Any> KClass<T>.valueField(): KProperty1<out T, *> {
+    @Suppress("UNCHECKED_CAST")
+    return valueClassFieldCache.getOrPut(this) {
+        require(isValue) { "$this is not a value class" }
+
+        // value classes always have a primary constructor...
+        val constructor = primaryConstructor!!.apply { isAccessible = true }
+        // ...and exactly one constructor parameter
+        val constructorParameter = constructor.parameters.first()
+        // ...with a backing field
+        val backingField = declaredMemberProperties
+            .first { it.name == constructorParameter.name }
+            .apply { isAccessible = true }
+
+        backingField
+    } as KProperty1<out T, *>
+}

mockk/common/src/main/kotlin/io/mockk/impl/recording/SignatureValueGenerator.kt

@@ -1,7 +1,13 @@
 package io.mockk.impl.recording
 
+import io.mockk.impl.instantiation.AbstractInstantiator
+import io.mockk.impl.instantiation.AnyValueGenerator
 import kotlin.reflect.KClass
 
 interface SignatureValueGenerator {
-    fun <T : Any> signatureValue(cls: KClass<T>, orInstantiateVia: () -> T): T
-}
+    fun <T : Any> signatureValue(
+        cls: KClass<T>,
+        anyValueGeneratorProvider: () -> AnyValueGenerator,
+        instantiator: AbstractInstantiator,
+    ): T
+}

mockk/common/src/main/kotlin/io/mockk/impl/recording/states/RecordingState.kt

@@ -42,15 +42,17 @@ abstract class RecordingState(recorder: CommonCallRecorder) : CallRecordingState
         recorder.calls.addAll(detector.calls)
     }
 
-    @Suppress("UNCHECKED_CAST")
     override fun <T : Any> matcher(matcher: Matcher<*>, cls: KClass<T>): T {
-        val signatureValue = recorder.signatureValueGenerator.signatureValue(cls) {
-            recorder.anyValueGenerator().anyValue(cls, isNullable = false) {
-                recorder.instantiator.instantiate(cls)
-            } as T
-        }
+        val signatureValue = recorder.signatureValueGenerator.signatureValue(
+            cls,
+            recorder.anyValueGenerator,
+            recorder.instantiator,
+        )
+
+        val packRef: Any = InternalPlatform.packRef(signatureValue)
+            ?: error("null packRef for $cls signature $signatureValue")
 
-        builder().addMatcher(matcher, InternalPlatform.packRef(signatureValue)!!)
+        builder().addMatcher(matcher, packRef)
 
         return signatureValue
     }

mockk/common/src/test/kotlin/io/mockk/it/ValueClassTest.kt

@@ -1,6 +1,8 @@
 package io.mockk.it
 
 import io.mockk.*
+import kotlin.jvm.JvmInline
+import kotlin.test.Ignore
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
@@ -43,14 +45,59 @@ class ValueClassTest {
 
         verify { mock.processValue(DummyValue(1)) }
     }
+
+    @Test
+    fun `any matcher for value class`() {
+        val mock = mockk<ValueServiceDummy>(relaxed = true)
+        val givenResult = 1
+        every { mock.doSomething(any()) } returns givenResult
+
+        val result = mock.doSomething(ValueDummy("moin"))
+
+        assertEquals(givenResult, result)
+    }
+
+    @Test
+    fun `slot for value class`() {
+        val mock = mockk<ValueServiceDummy>(relaxed = true)
+        val slot = slot<ValueDummy>()
+        val givenResult = 1
+        every { mock.doSomething(capture(slot)) } returns givenResult
+
+        val givenParameter = ValueDummy("s")
+
+        val result = mock.doSomething(givenParameter)
+
+        assertEquals(givenResult, result)
+        assertEquals(givenParameter, slot.captured)
+    }
+
+    @Test
+    fun `value class as return value`() {
+        val mock = mockk<ValueServiceDummy>(relaxed = true)
+        val givenResult = ValueDummy("moin")
+        every { mock.getSomething() } returns givenResult
+
+        val result = mock.getSomething()
+
+        assertEquals(givenResult, result)
+    }
 }
 
 // TODO should be value class in kotlin 1.5+
-private inline class DummyValue(val value: Int)
+inline class DummyValue(val value: Int)
 
-private class DummyService {
+class DummyService {
 
     fun requestValue()  = DummyValue(0)
 
     fun processValue(value: DummyValue)  = DummyValue(0)
 }
+
+@JvmInline
+value class ValueDummy(val value: String)
+
+interface ValueServiceDummy {
+    fun doSomething(value: ValueDummy): Int
+    fun getSomething(): ValueDummy
+}

mockk/jvm/src/main/kotlin/io/mockk/impl/recording/JvmSignatureValueGenerator.kt

@@ -1,11 +1,29 @@
 package io.mockk.impl.recording
 
-import java.util.*
+import io.mockk.InternalPlatformDsl
+import io.mockk.impl.instantiation.AbstractInstantiator
+import io.mockk.impl.instantiation.AnyValueGenerator
+import java.util.Random
 import kotlin.reflect.KClass
 import kotlin.reflect.full.cast
+import kotlin.reflect.full.primaryConstructor
+import kotlin.reflect.jvm.isAccessible
 
 class JvmSignatureValueGenerator(val rnd: Random) : SignatureValueGenerator {
-    override fun <T : Any> signatureValue(cls: KClass<T>, orInstantiateVia: () -> T): T {
+    override fun <T : Any> signatureValue(
+        cls: KClass<T>,
+        anyValueGeneratorProvider: () -> AnyValueGenerator,
+        instantiator: AbstractInstantiator,
+    ): T {
+
+        if (cls.isValue) {
+            val valueCls = InternalPlatformDsl.unboxClass(cls)
+            val valueSig = signatureValue(valueCls, anyValueGeneratorProvider, instantiator)
+
+            val constructor = cls.primaryConstructor!!.apply { isAccessible = true }
+            return constructor.call(valueSig)
+        }
+
         return cls.cast(
             when (cls) {
                 java.lang.Boolean::class -> rnd.nextBoolean()
@@ -17,8 +35,13 @@ class JvmSignatureValueGenerator(val rnd: Random) : SignatureValueGenerator {
                 java.lang.Float::class -> rnd.nextFloat()
                 java.lang.Double::class -> rnd.nextDouble()
                 java.lang.String::class -> rnd.nextLong().toString(16)
-                else -> orInstantiateVia()
+
+                else ->
+                    @Suppress("UNCHECKED_CAST")
+                    anyValueGeneratorProvider().anyValue(cls, isNullable = false) {
+                        instantiator.instantiate(cls)
+                    } as T
             }
         )
     }
-}
+}