Merge pull request #77 from mockito/issue/75

Implements ScalaNullResultGuardian

Author: ultrasecreth

.sbtopts

@@ -0,0 +1,4 @@
+-J-Xmx4G
+-J-XX:MaxMetaspaceSize=1G
+-J-XX:MaxPermSize=1G
+-J-XX:+CMSClassUnloadingEnabled

build.sbt

@@ -4,6 +4,8 @@ import scala.io.Source
 import scala.language.postfixOps
 import scala.util.Try
 
+ThisBuild / scalaVersion := "2.12.8"
+
 lazy val commonSettings =
   Seq(
     organization := "org.mockito",
@@ -26,6 +28,7 @@ lazy val commonSettings =
       "-Ypartial-unification",
       "-language:higherKinds",
       "-Xfatal-warnings",
+      "-language:reflectiveCalls",
 //      "-Xmacro-settings:mockito-print-when,mockito-print-do-something,mockito-print-verify,mockito-print-captor,mockito-print-matcher,mockito-print-extractor"
     ),
   )

common/src/main/scala/org/mockito/MockitoAPI.scala

@@ -33,7 +33,7 @@ private[mockito] trait MockCreator {
   def mock[T <: AnyRef: ClassTag: WeakTypeTag](mockSettings: MockSettings): T
   def mock[T <: AnyRef: ClassTag: WeakTypeTag](name: String)(implicit defaultAnswer: DefaultAnswer): T
 
-  def spy[T](realObj: T): T
+  def spy[T <: AnyRef: ClassTag: WeakTypeTag](realObj: T): T
   def spyLambda[T <: AnyRef: ClassTag](realObj: T): T
 
   /**
@@ -222,6 +222,9 @@ private[mockito] trait MockitoEnhancer extends MockCreator {
   override def mock[T <: AnyRef: ClassTag: WeakTypeTag](name: String)(implicit defaultAnswer: DefaultAnswer): T =
     mock(withSettings.name(name))
 
+  def spy[T <: AnyRef: ClassTag: WeakTypeTag](realObj: T): T =
+    mock[T](withSettings(DefaultAnswers.CallsRealMethods).spiedInstance(realObj))
+
   /**
    * Delegates to <code>Mockito.reset(T... mocks)</code>, but restores the default stubs that
    * deal with default argument values
@@ -317,11 +320,6 @@ private[mockito] trait Verifications {
  */
 private[mockito] trait Rest extends MockitoEnhancer with DoSomething with Verifications {
 
-  /**
-   * Delegates to <code>Mockito.spy()</code>, it's only here to expose the full Mockito API
-   */
-  def spy[T](realObj: T): T = Mockito.spy(realObj)
-
   /**
    * Creates a "spy" in a way that supports lambdas and anonymous classes as they don't work with the standard spy as
    * they are created as final classes by the compiler

common/src/main/scala/org/mockito/ReflectionUtils.scala

@@ -2,12 +2,41 @@ package org.mockito
 
 import java.util.function
 
-import org.mockito.internal.handler.ScalaMockHandler.{ArgumentExtractor, Extractors}
-
-import scala.reflect.runtime.universe._
+import org.mockito.internal.handler.ScalaMockHandler.{ ArgumentExtractor, Extractors }
+import org.mockito.invocation.InvocationOnMock
+import ru.vyarus.java.generics.resolver.GenericsResolver
 
 private[mockito] object ReflectionUtils {
 
+  import scala.reflect.runtime.{ universe => ru }
+  import ru._
+
+  private val mirror = runtimeMirror(getClass.getClassLoader)
+  private val customMirror = mirror.asInstanceOf[{
+    def methodToJava(sym: scala.reflect.internal.Symbols#MethodSymbol): java.lang.reflect.Method
+  }]
+
+  implicit class InvocationOnMockOps(invocation: InvocationOnMock) {
+    def returnType: Class[_] = {
+      val method = invocation.getMethod
+      val clazz  = method.getDeclaringClass
+      val javaReturnType = invocation.getMethod.getReturnType
+
+      if (javaReturnType == classOf[Object])
+        mirror
+          .classSymbol(clazz)
+          .info
+          .decls
+          .filter(d => d.isMethod && !d.isConstructor)
+          .find(d => customMirror.methodToJava(d.asInstanceOf[scala.reflect.internal.Symbols#MethodSymbol]) == method)
+          .map(_.asMethod)
+          .filter(_.returnType.typeSymbol.isClass)
+          .map(methodSymbol => mirror.runtimeClass(methodSymbol.returnType.typeSymbol.asClass))
+          .getOrElse(GenericsResolver.resolve(invocation.getMock.getClass).`type`(clazz).method(method).resolveReturnClass())
+      else javaReturnType
+    }
+  }
+
   def interfaces[T](implicit tag: WeakTypeTag[T]): List[Class[_]] =
     tag.tpe match {
       case RefinedType(types, _) =>

common/src/main/scala/org/mockito/internal/handler/ScalaMockHandler.scala

@@ -32,7 +32,7 @@ class ScalaMockHandler[T](mockSettings: MockCreationSettings[T]) extends MockHan
 
 object ScalaMockHandler {
   def apply[T](mockSettings: MockCreationSettings[T]): MockHandler[T] =
-    new InvocationNotifierHandler[T](new NullResultGuardian[T](new ScalaMockHandler(mockSettings)), mockSettings)
+    new InvocationNotifierHandler[T](new ScalaNullResultGuardian[T](new ScalaMockHandler(mockSettings)), mockSettings)
 
   private def readField[T](invocation: InterceptedInvocation, field: String): T = {
     val f = classOf[InterceptedInvocation].getDeclaredField(field)

common/src/main/scala/org/mockito/internal/handler/ScalaNullResultGuardian.scala

@@ -0,0 +1,20 @@
+package org.mockito.internal.handler
+import org.mockito.internal.util.Primitives.defaultValue
+import org.mockito.invocation.{ Invocation, InvocationContainer, MockHandler }
+import org.mockito.mock.MockCreationSettings
+import org.mockito.ReflectionUtils._
+
+class ScalaNullResultGuardian[T](delegate: MockHandler[T]) extends MockHandler[T] {
+
+  override def handle(invocation: Invocation): AnyRef = {
+    val result     = delegate.handle(invocation)
+    val returnType = invocation.returnType
+    if (result == null && returnType.isPrimitive)
+      defaultValue(returnType).asInstanceOf[AnyRef]
+    else
+      result
+  }
+
+  override def getMockSettings: MockCreationSettings[T]    = delegate.getMockSettings
+  override def getInvocationContainer: InvocationContainer = delegate.getInvocationContainer
+}

common/src/main/scala/org/mockito/stubbing/ReturnsSmartNulls.scala

@@ -2,22 +2,21 @@ package org.mockito.stubbing
 import java.lang.reflect.Modifier.isFinal
 
 import org.mockito.Mockito.mock
+import org.mockito.ReflectionUtils._
 import org.mockito.internal.debugging.LocationImpl
 import org.mockito.internal.exceptions.Reporter.smartNullPointerException
 import org.mockito.internal.stubbing.defaultanswers.ReturnsMoreEmptyValues
 import org.mockito.internal.util.ObjectMethodsGuru.isToStringMethod
 import org.mockito.invocation.{ InvocationOnMock, Location }
-import ru.vyarus.java.generics.resolver.GenericsResolver.resolve
 
 object ReturnsSmartNulls extends DefaultAnswer {
 
   val delegate = new ReturnsMoreEmptyValues
 
   override def apply(invocation: InvocationOnMock): Option[Any] = Option(delegate.answer(invocation)).orElse {
-    val method     = invocation.getMethod
-    val context    = resolve(invocation.getMock.getClass).`type`(method.getDeclaringClass)
-    val returnType = context.method(method).resolveReturnClass()
-    if (!returnType.isPrimitive && !isFinal(returnType.getModifiers))
+    val returnType = invocation.returnType
+
+    if (!returnType.isPrimitive && !isFinal(returnType.getModifiers) && classOf[Object] != returnType)
       Some(mock(returnType, ThrowsSmartNullPointer(invocation)))
     else
       None

core/src/main/scala/org/mockito/IdiomaticMockito.scala

@@ -22,7 +22,7 @@ trait IdiomaticMockito extends MockCreator {
   override def mock[T <: AnyRef: ClassTag: WeakTypeTag](implicit defaultAnswer: DefaultAnswer): T =
     MockitoSugar.mock[T]
 
-  override def spy[T](realObj: T): T = MockitoSugar.spy(realObj)
+  override def spy[T <: AnyRef: ClassTag: WeakTypeTag](realObj: T): T = MockitoSugar.spy(realObj)
 
   override def spyLambda[T <: AnyRef: ClassTag](realObj: T): T = MockitoSugar.spyLambda(realObj)