Extract all value class handling (type deduction, boxing, unboxing, etc.) to ValueClassSupport.kt

Author: m-koops

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

@@ -26,7 +26,9 @@
 package org.mockito.kotlin
 
 import org.mockito.ArgumentCaptor
+import org.mockito.kotlin.internal.toKotlinType
 import org.mockito.kotlin.internal.createInstance
+import org.mockito.kotlin.internal.valueClassInnerClass
 import java.lang.reflect.Array
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
@@ -164,53 +166,50 @@ class KArgumentCaptor<out T : Any?>(private val kType: KType) {
 
     private val captor: ArgumentCaptor<Any?> =
         if (clazz.isValue && !kType.isMarkedNullable) {
-            val boxImpl =
-                clazz.java.declaredMethods
-                    .single { it.name == "box-impl" && it.parameterCount == 1 }
-            boxImpl.parameters[0].type // is the boxed type of the value type
+            clazz.valueClassInnerClass()
         } else {
-            clazz.java
+            clazz
         }.let {
-            ArgumentCaptor.forClass(it)
+            ArgumentCaptor.forClass(it.java)
         }
 
     /**
      * The first captured value of the argument.
      * @throws IndexOutOfBoundsException if the value is not available.
      */
     val firstValue: T
-        get() = toKotlinType(captor.firstValue)
+        get() = captor.firstValue.toKotlinType(clazz)
 
     /**
      * The second captured value of the argument.
      * @throws IndexOutOfBoundsException if the value is not available.
      */
     val secondValue: T
-        get() = toKotlinType(captor.secondValue)
+        get() = captor.secondValue.toKotlinType(clazz)
 
     /**
      * The third captured value of the argument.
      * @throws IndexOutOfBoundsException if the value is not available.
      */
     val thirdValue: T
-        get() = toKotlinType(captor.thirdValue)
+        get() = captor.thirdValue.toKotlinType(clazz)
 
     /**
      * The last captured value of the argument.
      * @throws IndexOutOfBoundsException if the value is not available.
      */
     val lastValue: T
-        get() = toKotlinType(captor.lastValue)
+        get() = captor.lastValue.toKotlinType(clazz)
 
     /**
      * The *only* captured value of the argument,
      * or throws an exception if no value or more than one value was captured.
      */
     val singleValue: T
-        get() = toKotlinType(captor.singleValue)
+        get() = captor.singleValue.toKotlinType(clazz)
 
     val allValues: List<T>
-        get() = captor.allValues.map(::toKotlinType)
+        get() = captor.allValues.map { it.toKotlinType(clazz) }
 
     @Suppress("UNCHECKED_CAST")
     fun capture(): T {
@@ -221,30 +220,14 @@ class KArgumentCaptor<out T : Any?>(private val kType: KType) {
         // In Java, `captor.capture` returns null and so the method is called with `[null]`
         // In Kotlin, we have to create `[null]` explicitly.
         // This code-path is applied for non-vararg array arguments as well, but it seems to work fine.
-        return toKotlinType(captor.capture()) ?: if (clazz.java.isArray) {
+        return captor.capture().toKotlinType(clazz) ?: if (clazz.java.isArray) {
             singleElementArray()
         } else {
             createInstance(clazz)
         } as T
     }
 
     private fun singleElementArray(): Any? = Array.newInstance(clazz.java.componentType, 1)
-
-    @Suppress("UNCHECKED_CAST")
-    private fun toKotlinType(rawCapturedValue: Any?): T {
-        if (rawCapturedValue == null) return null as T
-
-        if (clazz.isValue && rawCapturedValue::class != clazz) {
-            return rawCapturedValue
-                .let {
-                    val boxImpl =
-                        clazz.java.declaredMethods.single { it.name == "box-impl" && it.parameterCount == 1 }
-                    boxImpl.invoke(null, it)
-                } as T
-        }
-
-        return rawCapturedValue as T
-    }
 }
 
 val <T> ArgumentCaptor<T>.firstValue: T

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

@@ -27,9 +27,12 @@ package org.mockito.kotlin
 
 import org.mockito.ArgumentMatcher
 import org.mockito.ArgumentMatchers
+import org.mockito.kotlin.internal.boxAsValueClass
 import org.mockito.kotlin.internal.createInstance
+import org.mockito.kotlin.internal.toJavaType
+import org.mockito.kotlin.internal.toKotlinType
+import org.mockito.kotlin.internal.valueClassInnerClass
 import kotlin.reflect.KClass
-import kotlin.reflect.typeOf
 
 /** Object argument that is equal to the given value. */
 inline fun <reified T : Any?> eq(value: T): T {
@@ -79,39 +82,15 @@ inline fun <reified T : Any?> anyArray(): Array<T> {
 }
 
 /** 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 boxImpl =
-        T::class.java.declaredMethods
-            .single { it.name == "box-impl" && it.parameterCount == 1 }
-    val boxedType = boxImpl.parameters[0].type
-
-    return boxImpl.invoke(null, ArgumentMatchers.any(boxedType)) as T
+inline fun <reified T> anyValueClass(): T {
+    val clazz = T::class
+    return ArgumentMatchers.any(clazz.valueClassInnerClass().java).boxAsValueClass(clazz)
 }
 
 inline fun <reified T> eqValueClass(value: T): T {
-    require(T::class.isValue) {
-        "${T::class.qualifiedName} is not a value class."
-    }
-
-    if (typeOf<T>().isMarkedNullable) {
-        // if the value is both value class and nullable, then Kotlin passes the value class boxed
-        // towards Mockito java code.
-        return ArgumentMatchers.eq(value)
+    return value.toJavaType().let {
+        (ArgumentMatchers.eq(it) ?: it).toKotlinType(T::class)
     }
-
-    val unboxImpl =
-        T::class.java.declaredMethods
-            .single { it.name == "unbox-impl" && it.parameterCount == 0 }
-    val unboxed = unboxImpl.invoke(value)
-
-    val boxImpl =
-        T::class.java.declaredMethods.single { it.name == "box-impl" && it.parameterCount == 1 }
-
-    return boxImpl.invoke(null, ArgumentMatchers.eq(unboxed) ?: unboxed) as T
 }
 
 /**

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

@@ -26,8 +26,6 @@
 package org.mockito.kotlin.internal
 
 import kotlin.reflect.KClass
-import kotlin.reflect.KProperty1
-import kotlin.reflect.full.primaryConstructor
 
 inline fun <reified T : Any> createInstance(): T {
     return createInstance(T::class)
@@ -48,13 +46,10 @@ fun <T : Any> createInstance(kClass: KClass<T>): T {
     }
 }
 
-@Suppress("UNCHECKED_CAST")
 private fun <T : Any> createInstanceNonPrimitive(kClass: KClass<T>): T {
     return if (kClass.isValue) {
-        val boxImpl =
-            kClass.java.declaredMethods.single { it.name == "box-impl" && it.parameterCount == 1 }
-        val wrappedType = getValueClassWrappedType(kClass)
-        boxImpl.invoke(null, createInstance(wrappedType)) as T
+        createInstance(kClass.valueClassInnerClass())
+            .boxAsValueClass(kClass)
     } else {
         castNull()
     }
@@ -68,11 +63,3 @@ private fun <T : Any> createInstanceNonPrimitive(kClass: KClass<T>): T {
  */
 @Suppress("UNCHECKED_CAST")
 private fun <T> castNull(): T = null as T
-
-private fun getValueClassWrappedType(kClass: KClass<*>): KClass<*> {
-    require(kClass.isValue)
-
-    val primaryConstructor = checkNotNull(kClass.primaryConstructor)
-    val wrappedType = primaryConstructor.parameters.single().type
-    return wrappedType.classifier as KClass<*>
-}

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

@@ -0,0 +1,81 @@
+/*
+ * 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 java.lang.reflect.Method
+import kotlin.reflect.KClass
+import kotlin.reflect.typeOf
+
+@Suppress("UNCHECKED_CAST")
+fun <T : Any?> Any?.toKotlinType(clazz: KClass<*>): T {
+    if (this == null) return null as T
+
+    return if (clazz.isValue && this::class != clazz) {
+        this.boxAsValueClass(clazz) as T
+    } else {
+        this as T
+    }
+}
+
+inline fun <reified T> T.toJavaType(): Any? {
+    if (this == null) return null
+
+    return if (this::class.isValue && !typeOf<T>().isMarkedNullable) {
+        this.unboxValueClass()
+    } else {
+        // if the value is both value class and nullable, then Kotlin passes the value class boxed
+        // towards Mockito java code.
+        this
+    }
+}
+
+@Suppress("UNCHECKED_CAST")
+fun <T : Any?> Any?.boxAsValueClass(clazz: KClass<*>): T {
+    require(clazz.isValue) { "${clazz.qualifiedName} is not a value class." }
+
+    val boxImpl = clazz.boxImpl()
+    return boxImpl.invoke(null, this) as T
+}
+
+fun Any.unboxValueClass(): Any {
+    val clazz = this::class
+    require(clazz.isValue) { "${clazz.qualifiedName} is not a value class." }
+
+    val unboxImpl =
+        clazz.java.declaredMethods
+            .single { it.name == "unbox-impl" && it.parameterCount == 0 }
+
+    return unboxImpl.invoke(this)
+}
+
+fun KClass<*>.valueClassInnerClass(): KClass<*> {
+    require(isValue) { "$qualifiedName is not a value class." }
+
+    return boxImpl().parameters[0].type.kotlin
+}
+
+private fun KClass<*>.boxImpl(): Method =
+    java.declaredMethods.single { it.name == "box-impl" && it.parameterCount == 1 }