Introduce instance creators.

These are functions `() -> T` that are invoked when
an instance of `T` is needed, instead of manually
trying to figure out which constructor to use.

Fixes #20.

Author: nhaarman

mockito-kotlin/src/main/kotlin/com/nhaarman/mockito_kotlin/CreateInstance.kt

@@ -29,6 +29,7 @@ import org.mockito.Answers
 import org.mockito.internal.creation.MockSettingsImpl
 import org.mockito.internal.creation.bytebuddy.MockMethodInterceptor
 import org.mockito.internal.util.MockUtil
+import java.lang.reflect.InvocationTargetException
 import java.lang.reflect.Modifier
 import java.lang.reflect.ParameterizedType
 import java.lang.reflect.Type
@@ -49,16 +50,18 @@ inline fun <reified T> createArrayInstance() = arrayOf<T>()
 
 inline fun <reified T : Any> createInstance() = createInstance(T::class)
 
+@Suppress("UNCHECKED_CAST")
 fun <T : Any> createInstance(kClass: KClass<T>): T {
-    return when {
-        kClass.hasObjectInstance() -> kClass.objectInstance!!
-        kClass.isMockable() -> kClass.java.uncheckedMock()
-        kClass.isPrimitive() -> kClass.toDefaultPrimitiveValue()
-        kClass.isEnum() -> kClass.java.enumConstants.first()
-        kClass.isArray() -> kClass.toArrayInstance()
+    return MockitoKotlin.instanceCreator(kClass)?.invoke() as T? ?:
+            when {
+                kClass.hasObjectInstance() -> kClass.objectInstance!!
+                kClass.isMockable() -> kClass.java.uncheckedMock()
+                kClass.isPrimitive() -> kClass.toDefaultPrimitiveValue()
+                kClass.isEnum() -> kClass.java.enumConstants.first()
+                kClass.isArray() -> kClass.toArrayInstance()
         kClass.isClassObject() -> kClass.toClassObject()
-        else -> kClass.easiestConstructor().newInstance()
-    }
+                else -> kClass.easiestConstructor().newInstance()
+            }
 }
 
 /**
@@ -134,10 +137,23 @@ private fun <T : Any> KClass<T>.toClassObject(): T {
 }
 
 private fun <T : Any> KFunction<T>.newInstance(): T {
-    isAccessible = true
-    return callBy(parameters.associate {
-        it to it.type.createNullableInstance<T>()
-    })
+    try {
+        isAccessible = true
+        return callBy(parameters.associate {
+            it to it.type.createNullableInstance<T>()
+        })
+    } catch(e: InvocationTargetException) {
+        throw MockitoKotlinException(
+                """
+
+        Could not create an instance of class ${this.returnType}, because of an error with the following message:
+
+            "${e.cause?.message}"
+
+        Try registering an instance creator yourself, using MockitoKotlin.registerInstanceCreator<${this.returnType}> {...}.""",
+                e.cause
+        )
+    }
 }
 
 @Suppress("UNCHECKED_CAST")

mockito-kotlin/src/main/kotlin/com/nhaarman/mockito_kotlin/MockitoKotlin.kt

@@ -0,0 +1,69 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2016 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 com.nhaarman.mockito_kotlin
+
+import java.util.*
+import kotlin.reflect.KClass
+
+class MockitoKotlin {
+
+    companion object {
+
+        /**
+         * Maps KClasses to functions that can create an instance of that KClass.
+         */
+        private val creators: MutableMap<KClass<*>, () -> Any> = HashMap()
+
+        /**
+         * Registers a function to be called when an instance of T is necessary.
+         */
+        inline fun <reified T : Any> registerInstanceCreator(noinline creator: () -> T) = registerInstanceCreator(T::class, creator)
+
+        /**
+         * Registers a function to be called when an instance of T is necessary.
+         */
+        fun <T : Any> registerInstanceCreator(kClass: KClass<T>, creator: () -> T) = creators.put(kClass, creator)
+
+        /**
+         * Unregisters an instance creator.
+         */
+        inline fun <reified T : Any> unregisterInstanceCreator() = unregisterInstanceCreator(T::class)
+
+        /**
+         * Unregisters an instance creator.
+         */
+        fun <T : Any> unregisterInstanceCreator(kClass: KClass<T>) = creators.remove(kClass)
+
+        /**
+         * Clears al instance creators.
+         */
+        fun resetInstanceCreators() = creators.clear()
+
+        internal fun <T : Any> instanceCreator(kClass: KClass<T>): (() -> Any)? {
+            return creators[kClass]
+        }
+    }
+}

mockito-kotlin/src/main/kotlin/com/nhaarman/mockito_kotlin/MockitoKotlinException.kt

@@ -0,0 +1,28 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2016 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 com.nhaarman.mockito_kotlin
+
+class MockitoKotlinException(message: String?, cause: Throwable?) : RuntimeException(message, cause)

mockito-kotlin/src/test/kotlin/CreateInstanceTest.kt

@@ -24,6 +24,8 @@
  */
 
 import com.nhaarman.expect.expect
+import com.nhaarman.expect.expectErrorWithMessage
+import com.nhaarman.mockito_kotlin.MockitoKotlin
 import com.nhaarman.mockito_kotlin.createInstance
 import org.junit.Test
 import java.util.*
@@ -403,6 +405,25 @@ class CreateInstanceTest {
         expect(result).toBe(UUID(0, 0))
     }
 
+    @Test
+    fun registeredInstanceCreator() {
+        /* Given */
+        MockitoKotlin.registerInstanceCreator { ForbiddenConstructor(2) }
+
+        /* When */
+        val result = createInstance<ForbiddenConstructor>()
+
+        /* Then */
+        expect(result).toNotBeNull()
+    }
+
+    @Test
+    fun failedConstructor_throwsDescriptiveError() {
+        expectErrorWithMessage("Could not create an instance of class") on {
+            createInstance<ForbiddenConstructor>()
+        }
+    }
+
     private class PrivateClass private constructor(val data: String)
 
     class ClosedClass
@@ -428,5 +449,15 @@ class CreateInstanceTest {
     class ParameterizedClass<T>(val t: T)
     class NullableParameterClass(val s: String?)
 
+    class ForbiddenConstructor {
+
+        constructor() {
+            throw AssertionError("Forbidden.")
+        }
+
+        constructor(value: Int) {
+        }
+    }
+
     enum class MyEnum { VALUE, ANOTHER_VALUE }
 }

mockito-kotlin/src/test/kotlin/MockitoKotlinTest.kt

@@ -0,0 +1,59 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2016 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.
+ */
+
+import com.nhaarman.expect.expect
+import com.nhaarman.mockito_kotlin.MockitoKotlin
+import com.nhaarman.mockito_kotlin.createInstance
+import org.junit.Test
+
+class MockitoKotlinTest {
+
+    @Test
+    fun register() {
+        /* Given */
+        val closed = Closed()
+        MockitoKotlin.registerInstanceCreator { closed }
+
+        /* When */
+        val result = createInstance<Closed>()
+
+        /* Then */
+        expect(result).toBe(closed)
+    }
+
+    @Test
+    fun unregister() {
+        /* Given */
+        val closed = Closed()
+        MockitoKotlin.registerInstanceCreator { closed }
+        MockitoKotlin.unregisterInstanceCreator<Closed>()
+
+        /* When */
+        val result = createInstance<Closed>()
+
+        /* Then */
+        expect(result).toNotBeReferentially(closed)
+    }
+}