Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.mockito.WhenMacro.scala Maven / Gradle / Ivy
package org.mockito
import org.mockito.Utils._
import org.mockito.stubbing.{ ScalaFirstStubbing, ScalaOngoingStubbing }
import scala.reflect.ClassTag
import scala.reflect.macros.blackbox
object WhenMacro {
private val ShouldReturnOptions = Set("shouldReturn", "mustReturn", "returns")
private val FunctionalShouldReturnOptions = ShouldReturnOptions.map(_ + "F")
private val FunctionalShouldReturnOptions2 = ShouldReturnOptions.map(_ + "FG")
def shouldReturn[T: c.WeakTypeTag](c: blackbox.Context): c.Tree = {
import c.universe._
val r = c.macroApplication match {
case q"$_.StubbingOps[$t]($obj.$method[..$targs](...$args)).$m" if ShouldReturnOptions.contains(m.toString) =>
val newArgs = args.map(a => transformArgs(c)(a))
q"new _root_.org.mockito.IdiomaticMockitoBase.ReturnActions(_root_.org.mockito.Mockito.when[$t]($obj.$method[..$targs](...$newArgs)))"
case q"$_.StubbingOps[$t]($obj.$method[..$targs]).$m" if ShouldReturnOptions.contains(m.toString) =>
q"new _root_.org.mockito.IdiomaticMockitoBase.ReturnActions(_root_.org.mockito.Mockito.when[$t]($obj.$method[..$targs]))"
case q"$_.$cls[..$_]($obj.$method[..$targs](...$args)).$m"
if cls.toString.startsWith("StubbingOps") && FunctionalShouldReturnOptions.contains(m.toString) =>
val newArgs = args.map(a => transformArgs(c)(a))
q"new _root_.org.mockito.${packageName(c)(cls)}.${className(c)(cls, "IdiomaticMockito")}.ReturnActions(_root_.org.mockito.Mockito.when($obj.$method[..$targs](...$newArgs)))"
case q"$_.$cls[..$_]($obj.$method[..$targs]).$m"
if cls.toString.startsWith("StubbingOps") && FunctionalShouldReturnOptions.contains(m.toString) =>
q"new _root_.org.mockito.${packageName(c)(cls)}.${className(c)(cls, "IdiomaticMockito")}.ReturnActions(_root_.org.mockito.Mockito.when($obj.$method[..$targs]))"
case q"$_.$cls[..$_]($obj.$method[..$targs](...$args)).$m"
if cls.toString.startsWith("StubbingOps2") && FunctionalShouldReturnOptions2.contains(m.toString) =>
val newArgs = args.map(a => transformArgs(c)(a))
q"new _root_.org.mockito.${packageName(c)(cls)}.${className(c)(cls, "IdiomaticMockito")}.ReturnActions2(_root_.org.mockito.Mockito.when($obj.$method[..$targs](...$newArgs)))"
case q"$_.$cls[..$_]($obj.$method[..$targs]).$m"
if cls.toString.startsWith("StubbingOps2") && FunctionalShouldReturnOptions2.contains(m.toString) =>
q"new _root_.org.mockito.${packageName(c)(cls)}.${className(c)(cls, "IdiomaticMockito")}.ReturnActions2(_root_.org.mockito.Mockito.when($obj.$method[..$targs]))"
case o => throw new Exception(s"Couldn't recognize ${show(o)}")
}
if (c.settings.contains("mockito-print-when")) println(show(r))
r
}
def isLenient[T: c.WeakTypeTag](c: blackbox.Context)(): c.Expr[Unit] = {
import c.universe._
val r = c.Expr[Unit] {
c.macroApplication match {
case q"$_.StubbingOps[$t]($obj.$method[..$targs](...$args)).isLenient()" =>
val newArgs = args.map(a => transformArgs(c)(a))
q"new _root_.org.mockito.stubbing.ScalaFirstStubbing(_root_.org.mockito.Mockito.when[$t]($obj.$method[..$targs](...$newArgs))).isLenient()"
case q"$_.StubbingOps[$t]($obj.$method[..$targs]).isLenient()" =>
q"new _root_.org.mockito.stubbing.ScalaFirstStubbing(_root_.org.mockito.Mockito.when[$t]($obj.$method[..$targs])).isLenient()"
case o => throw new Exception(s"Couldn't recognize ${show(o)}")
}
}
if (c.settings.contains("mockito-print-lenient")) println(show(r.tree))
r
}
object RealMethod {
def willBe(called: Called.type): Called.type = called
}
val ShouldCallOptions = Set("shouldCall", "mustCall", "calls")
def shouldCallRealMethod[T: c.WeakTypeTag](c: blackbox.Context)(crm: c.Expr[RealMethod.type]): c.Expr[ScalaOngoingStubbing[T]] = {
import c.universe._
val r = c.Expr[ScalaOngoingStubbing[T]] {
c.macroApplication match {
case q"$_.StubbingOps[$t]($obj.$method[..$targs](...$args)).$m($_.realMethod)" if ShouldCallOptions.contains(m.toString) =>
val newArgs = args.map(a => transformArgs(c)(a))
q"new _root_.org.mockito.stubbing.ScalaOngoingStubbing(_root_.org.mockito.Mockito.when[$t]($obj.$method[..$targs](...$newArgs)).thenCallRealMethod())"
case q"$_.StubbingOps[$t]($obj.$method[..$targs]).$m($_.realMethod)" if ShouldCallOptions.contains(m.toString) =>
q"new _root_.org.mockito.stubbing.ScalaOngoingStubbing(_root_.org.mockito.Mockito.when[$t]($obj.$method[..$targs]).thenCallRealMethod())"
case o => throw new Exception(s"Couldn't recognize ${show(o)}")
}
}
if (c.settings.contains("mockito-print-when")) println(show(r.tree))
r
}
private val ShouldThrowOptions = Set("shouldThrow", "mustThrow", "throws")
private val FunctionalShouldFailOptions = Set("shouldFailWith", "mustFailWith", "failsWith", "raises")
private val FunctionalShouldFailOptions2 = Set("shouldFailWithG", "mustFailWithG", "failsWithG", "raisesG")
def shouldThrow[T: c.WeakTypeTag](c: blackbox.Context): c.Tree = {
import c.universe._
val r = c.macroApplication match {
case q"$_.StubbingOps[$t]($obj.$method[..$targs](...$args)).$m" if ShouldThrowOptions.contains(m.toString) =>
val newArgs = args.map(a => transformArgs(c)(a))
q"new _root_.org.mockito.IdiomaticMockitoBase.ThrowActions(_root_.org.mockito.Mockito.when[$t]($obj.$method[..$targs](...$newArgs)))"
case q"$_.StubbingOps[$t]($obj.$method[..$targs]).$m" if ShouldThrowOptions.contains(m.toString) =>
q"new _root_.org.mockito.IdiomaticMockitoBase.ThrowActions(_root_.org.mockito.Mockito.when[$t]($obj.$method[..$targs]))"
case q"$_.$cls[..$_]($obj.$method[..$targs](...$args)).$m"
if cls.toString.startsWith("StubbingOps") && FunctionalShouldFailOptions.contains(m.toString) =>
val newArgs = args.map(a => transformArgs(c)(a))
q"new _root_.org.mockito.${packageName(c)(cls)}.${className(c)(cls, "IdiomaticMockito")}.ThrowActions(_root_.org.mockito.Mockito.when($obj.$method[..$targs](...$newArgs)))"
case q"$_.$cls[..$_]($obj.$method[..$targs]).$m"
if cls.toString.startsWith("StubbingOps") && FunctionalShouldFailOptions.contains(m.toString) =>
q"new _root_.org.mockito.${packageName(c)(cls)}.${className(c)(cls, "IdiomaticMockito")}.ThrowActions(_root_.org.mockito.Mockito.when($obj.$method[..$targs]))"
case q"$_.$cls[..$_]($obj.$method[..$targs](...$args)).$m"
if cls.toString.startsWith("StubbingOps2") && FunctionalShouldFailOptions2.contains(m.toString) =>
val newArgs = args.map(a => transformArgs(c)(a))
q"new _root_.org.mockito.${packageName(c)(cls)}.${className(c)(cls, "IdiomaticMockito")}.ThrowActions2(_root_.org.mockito.Mockito.when($obj.$method[..$targs](...$newArgs)))"
case q"$_.$cls[..$_]($obj.$method[..$targs]).$m"
if cls.toString.startsWith("StubbingOps2") && FunctionalShouldFailOptions2.contains(m.toString) =>
q"new _root_.org.mockito.${packageName(c)(cls)}.${className(c)(cls, "IdiomaticMockito")}.ThrowActions2(_root_.org.mockito.Mockito.when($obj.$method[..$targs]))"
case o => throw new Exception(s"Couldn't recognize ${show(o)}")
}
if (c.settings.contains("mockito-print-when")) println(show(r))
r
}
class AnswerActions[T](os: ScalaFirstStubbing[T]) {
def apply(f: => T): ScalaOngoingStubbing[T] = os thenAnswer f
def apply[P0](f: P0 => T)(implicit classTag: ClassTag[P0] = defaultClassTag[P0]): ScalaOngoingStubbing[T] =
os thenAnswer f
def apply[P0, P1](f: (P0, P1) => T): ScalaOngoingStubbing[T] = os thenAnswer f
def apply[P0, P1, P2](f: (P0, P1, P2) => T): ScalaOngoingStubbing[T] = os thenAnswer f
def apply[P0, P1, P2, P3](f: (P0, P1, P2, P3) => T): ScalaOngoingStubbing[T] = os thenAnswer f
def apply[P0, P1, P2, P3, P4](f: (P0, P1, P2, P3, P4) => T): ScalaOngoingStubbing[T] = os thenAnswer f
def apply[P0, P1, P2, P3, P4, P5](f: (P0, P1, P2, P3, P4, P5) => T): ScalaOngoingStubbing[T] = os thenAnswer f
def apply[P0, P1, P2, P3, P4, P5, P6](f: (P0, P1, P2, P3, P4, P5, P6) => T): ScalaOngoingStubbing[T] = os thenAnswer f
def apply[P0, P1, P2, P3, P4, P5, P6, P7](f: (P0, P1, P2, P3, P4, P5, P6, P7) => T): ScalaOngoingStubbing[T] = os thenAnswer f
def apply[P0, P1, P2, P3, P4, P5, P6, P7, P8](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8) => T): ScalaOngoingStubbing[T] = os thenAnswer f
def apply[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) => T): ScalaOngoingStubbing[T] =
os thenAnswer f
def apply[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) => T): ScalaOngoingStubbing[T] =
os thenAnswer f
}
private val ShouldAnswerOptions = Set("shouldAnswer", "mustAnswer", "answers")
private val FunctionalShouldAnswerOptions = ShouldAnswerOptions.map(_ + "F")
private val FunctionalShouldAnswerOptions2 = ShouldAnswerOptions.map(_ + "FG")
def shouldAnswer[T: c.WeakTypeTag](c: blackbox.Context): c.Tree = {
import c.universe._
val r = c.macroApplication match {
case q"$_.StubbingOps[$t]($obj.$method[..$targs](...$args)).$m" if ShouldAnswerOptions.contains(m.toString) =>
val newArgs = args.map(a => transformArgs(c)(a))
q"new _root_.org.mockito.WhenMacro.AnswerActions(_root_.org.mockito.Mockito.when[$t]($obj.$method[..$targs](...$newArgs)))"
case q"$_.StubbingOps[$t]($obj.$method[..$targs]).$m" if ShouldAnswerOptions.contains(m.toString) =>
q"new _root_.org.mockito.WhenMacro.AnswerActions(_root_.org.mockito.Mockito.when[$t]($obj.$method[..$targs]))"
case q"$_.$cls[..$_]($obj.$method[..$targs](...$args)).$m"
if cls.toString.startsWith("StubbingOps") && FunctionalShouldAnswerOptions.contains(m.toString) =>
val newArgs = args.map(a => transformArgs(c)(a))
q"new _root_.org.mockito.${packageName(c)(cls)}.${className(c)(cls, "IdiomaticMockito")}.AnswerActions(_root_.org.mockito.Mockito.when($obj.$method[..$targs](...$newArgs)))"
case q"$_.$cls[..$_]($obj.$method[..$targs]).$m"
if cls.toString.startsWith("StubbingOps") && FunctionalShouldAnswerOptions.contains(m.toString) =>
q"new _root_.org.mockito.${packageName(c)(cls)}.${className(c)(cls, "IdiomaticMockito")}.AnswerActions(_root_.org.mockito.Mockito.when($obj.$method[..$targs]))"
case q"$_.$cls[..$_]($obj.$method[..$targs](...$args)).$m"
if cls.toString.startsWith("StubbingOps2") && FunctionalShouldAnswerOptions2.contains(m.toString) =>
val newArgs = args.map(a => transformArgs(c)(a))
q"new _root_.org.mockito.${packageName(c)(cls)}.${className(c)(cls, "IdiomaticMockito")}.AnswerActions2(_root_.org.mockito.Mockito.when($obj.$method[..$targs](...$newArgs)))"
case q"$_.$cls[..$_]($obj.$method[..$targs]).$m"
if cls.toString.startsWith("StubbingOps2") && FunctionalShouldAnswerOptions2.contains(m.toString) =>
q"new _root_.org.mockito.${packageName(c)(cls)}.${className(c)(cls, "IdiomaticMockito")}.AnswerActions2(_root_.org.mockito.Mockito.when($obj.$method[..$targs]))"
case o => throw new Exception(s"Couldn't recognize ${show(o)}")
}
if (c.settings.contains("mockito-print-when")) println(show(r))
r
}
}
