Fixed infinite loop caused by 'copy constructors' invoked by createInstance. The fix is to skip all constructors that take in parameters with same type as the object we are trying to build.

Author: desilvai

mockito-kotlin/build.gradle

@@ -62,4 +62,4 @@ dokka {
         suffix = "#L"
     }
 }
-javadoc.dependsOn dokka
+javadoc.dependsOn dokka

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

@@ -85,14 +85,26 @@ fun <T : Any> createInstance(kClass: KClass<T>): T {
 private fun <T : Any> KClass<T>.easiestConstructor(): KFunction<T> {
     return constructors
             .sortedBy { it.parameters.size }
+            .withoutParametersOfType(this.defaultType)
             .withoutArrayParameters()
-            .firstOrNull() ?: constructors.sortedBy { it.parameters.size }.first()
+            .firstOrNull() ?: constructors.sortedBy { it.parameters.size }
+                                          .withoutParametersOfType(this.defaultType)
+                                          .first()
 }
 
 private fun <T> List<KFunction<T>>.withoutArrayParameters() = filter {
     it.parameters.filter { parameter -> parameter.type.toString().toLowerCase().contains("array") }.isEmpty()
 }
 
+/**
+ * Filters out functions with the given type.
+ * This is especially useful to avoid infinite loops where constructors
+ * accepting a parameter of their own type, e.g. 'copy constructors'.
+ */
+private fun <T: Any> List<KFunction<T>>.withoutParametersOfType(type: KType) = filter {
+    it.parameters.filter { it.type == type }.isEmpty()
+}
+
 @Suppress("SENSELESS_COMPARISON")
 private fun KClass<*>.hasObjectInstance() = objectInstance != null
 

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

@@ -436,6 +436,27 @@ class CreateInstanceTest {
         expect(result).toNotBeNull()
     }
 
+    /**
+     * Bug:  When the copy constructor is selected, we end up with an infinite
+     *       loop.  Instead, we want to select a constructor that doesn't
+     *       take in a parameter with the same type as the one we are building.
+     *
+     * GIVEN a class with a copy constructor (in the case of the bug, the copy
+     *       constructor has to be selected, so it must have fewer parameters
+     *       than all other constructors)
+     * WHEN we make an instance of the given class
+     * THEN we expect that the new, non-null instance will be created without
+     *       an exception
+     */
+    @Test
+    fun copyConstructorDoesNotCauseException() {
+        /* When */
+        val result = createInstance(WithCopyConstructor::class)
+
+        /* Then */
+        expect(result).toNotBeNull()
+    }
+
     private class PrivateClass private constructor(val data: String)
 
     class ClosedClass
@@ -475,5 +496,15 @@ class CreateInstanceTest {
         constructor(c: ForbiddenConstructor) : this()
     }
 
+    /**
+     * Bug: When the copy constructor is selected, then create instance gets
+     * into an infinite loop.  We should never use the copy constructor in
+     * createInstance.
+     */
+    data class WithCopyConstructor private constructor(val x: String,
+                                                       val y: String) {
+        constructor(other: WithCopyConstructor): this(other.x, other.y)
+    }
+
     enum class MyEnum { VALUE, ANOTHER_VALUE }
 }