From cd2c09652f230f5fa63cfcfffc4a2e19ff5f25eb Mon Sep 17 00:00:00 2001 From: Zachary Voase Date: Thu, 19 Feb 2015 23:42:27 +0000 Subject: [PATCH] [util-test] Easy argument capture for Mockito mocks. Problem Mockito's ArgumentCaptor enables you to capture the arguments that were passed to stubbed-out methods on mocks, to make assertions on them. However, the API for ArgumentCaptor was built for Java and is kind of clunky compared to what we expect in Scala. An alternative to using ArgumentCaptor is to use Mockito argument matchers in when(myObj.method(...)). However, this means every assertion you want to make has to be encapsulated in a custom matcher subclass, and you can't make assertions spanning more than one argument in each stubbed method invocation. For example, you might want to check that a key-value store wrapper object was called with a key of "foo" and a timeout of 10 seconds, and Mockito argument matchers would not be able to provide this. Another alternative is to use matchers in a verify(myMock, times(N)).someMethod(...) call, but this suffers from the same problem of having to write a specific matcher subclass for any non-standard assertions. Solution The ArgumentCapture trait can be mixed into your test class and has two methods, capturingOne and capturingAll, which capture the invocations of your stubbed methods as a tuple or Seq of tuples. Here's an example: when(myObj.lookup(any[String], any[Duration])).thenReturn(someValue) // The call to myObj.lookup will normally live somewhere inside the // subject under test. assert(myObj.lookup("foo", 10.seconds) === someValue) val (key, timeout) = capturingOne(verify(myObj).lookup _) assert(key === "foo") assert(timeout === 10.seconds) An example which uses capturingAll and doesn't make any assertions about the order of the stubbed method calls (forExactly is defined on the org.scalatest.Inspectors trait): val requests = capturingAll(verify(myObj, times(2)).lookup _) forExactly(1, requests) { (key, timeout) => assert(key === "foo") assert(timeout === 10.seconds) } forExactly(1, requests) { (key, timeout) => assert(key === "bar") assert(timeout === 2.seconds) } =================== https://github.com/twitter/util/pull/124 RB_ID=587072 TBR=true --- codegen/Makefile | 10 + codegen/README.markdown | 25 + codegen/requirements.txt | 1 + codegen/util-test/ArgumentCapture.scala.mako | 103 ++ project/Build.scala | 5 +- util-test/src/main/scala/BUILD | 1 + .../util/testing/ArgumentCapture.scala | 1134 +++++++++++++++++ .../util/testing/ArgumentCaptureTest.scala | 131 ++ 8 files changed, 1409 insertions(+), 1 deletion(-) create mode 100644 codegen/Makefile create mode 100644 codegen/README.markdown create mode 100644 codegen/requirements.txt create mode 100644 codegen/util-test/ArgumentCapture.scala.mako create mode 100644 util-test/src/main/scala/com/twitter/util/testing/ArgumentCapture.scala create mode 100644 util-test/src/test/scala/com/twitter/util/testing/ArgumentCaptureTest.scala diff --git a/codegen/Makefile b/codegen/Makefile new file mode 100644 index 0000000000..d6ff1b41e7 --- /dev/null +++ b/codegen/Makefile @@ -0,0 +1,10 @@ +usage: + @echo 'No default make target is provided.' + @echo 'Run `make ` to run the code generator on the given file,' + @echo 'or edit the Makefile to change how the generated file is produced.' + @false + +../util-test/src/main/scala/com/twitter/util/testing/ArgumentCapture.scala: util-test/ArgumentCapture.scala.mako + mako-render util-test/ArgumentCapture.scala.mako > $@ + +.PHONY: usage diff --git a/codegen/README.markdown b/codegen/README.markdown new file mode 100644 index 0000000000..cbb485ed8d --- /dev/null +++ b/codegen/README.markdown @@ -0,0 +1,25 @@ +# Code Generators + +This directory contains templates and executables for generating Scala code. We +normally need to do this when defining a function or method that accepts a +variable number of type parameters. For example, we may want to define a `zip` +function for tuples of arbitrary size: + + def zip[A, B](a: Seq[A], b: Seq[B]): Seq[(A, B)] + def zip[A, B, C](a: Seq[A], b: Seq[B], c: Seq[C]): Seq[(A, B, C)] + def zip[A, B, C, D] // and so on... + +There isn't a native way to do this sort of thing in pure Scala (hence the +existence of Tuple1 through Tuple22, Function1...22, etc.). + +## Usage + +A Makefile exists which can build the code-generated files. To (re-)generate a +file: + + make ../util-something/path/to/File.scala + +The Mako Python templating library is used by some targets, and it can be +installed with `pip`: + + pip install -r requirements.txt diff --git a/codegen/requirements.txt b/codegen/requirements.txt new file mode 100644 index 0000000000..1eab450f2b --- /dev/null +++ b/codegen/requirements.txt @@ -0,0 +1 @@ +mako>=1.0.0 diff --git a/codegen/util-test/ArgumentCapture.scala.mako b/codegen/util-test/ArgumentCapture.scala.mako new file mode 100644 index 0000000000..b1ff2cc2e4 --- /dev/null +++ b/codegen/util-test/ArgumentCapture.scala.mako @@ -0,0 +1,103 @@ +<%! +TYPE_VARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' +MAX_ARITY = 22 + +def nested_tuples(n): + """ + >>> nested_tuples(2) + (a, b) + >>> nested_tuples(3) + ((a, b), c) + >>> nested_tuples(5) + '((((a, b), c), d), e)' + """ + def pairwise(elems): + if not elems: return '' + elif len(elems) == 1: return elems[0] + else: return '({}, {})'.format(pairwise(elems[:-1]), elems[-1]) + return pairwise(TYPE_VARS.lower()[:n]) + +def flat_tuple(n): + return '({})'.format(', '.join(TYPE_VARS.lower()[:n])) +%>\ +package com.twitter.util.testing + +import java.util.{List => JList} +import org.mockito.ArgumentCaptor +import org.mockito.exceptions.Reporter +import scala.collection.JavaConverters._ +import scala.reflect._ + +// This file was generated from codegen/util-test/ArgumentCapture.scala.mako + +trait ArgumentCapture { + /** + * Enables capturingOne to be implemented over capturingAll with the same behavior as ArgumentCaptor.getValue + */ + private[this] def noArgWasCaptured(): Nothing = { + new Reporter().noArgumentValueWasCaptured() // this always throws an exception + throw new RuntimeException("this should be unreachable, but allows the method to be of type Nothing") + } + + /** + * Capture all the invocations from a verify(mock).method(arg) call. + * + * Example: + * val requests = capturingAll(verify(myAPIEndpoint, times(4)).authenticate _) + * requests.length must equal (4) + */ + def capturingAll[T: ClassTag](f: T => _): Seq[T] = { + val argCaptor = ArgumentCaptor.forClass(classTag[T].runtimeClass.asInstanceOf[Class[T]]) + f(argCaptor.capture()) + argCaptor.getAllValues.asScala.toSeq + } + + /** + * Capture an argument from a verify(mock).method(arg) call. + * + * Example: + * val request = capturingOne(verify(myAPIEndpoint).authenticate _) + * request.userId must equal (123L) + * request.password must equal ("reallySecurePassword") + */ + def capturingOne[T: ClassTag](f: T => _): T = + capturingAll[T](f).lastOption.getOrElse(noArgWasCaptured())\ + + % for i in xrange(2, MAX_ARITY + 1): +<% + types = ', '.join(TYPE_VARS[:i]) + types_with_class_tags = ', '.join('{}: ClassTag'.format(t) for t in TYPE_VARS[:i]) + iterable_args = ', '.join('arg{}: Iterable[{}]'.format(j, type) for j, type in enumerate(TYPE_VARS[:i])) +%> + /** Zip ${i} iterables together into a Seq of ${i}-tuples. */ + private[this] def zipN[${types}](${iterable_args}): Seq[(${types})] = { + % if i == 2: + arg0.zip(arg1).toSeq + % else: + arg0 + % for j in xrange(1, i): + .zip(arg${j}) + % endfor + .map({ case ${nested_tuples(i)} => ${flat_tuple(i)} }) + .toSeq + % endif + } + + /** Capture all invocations of a mocked ${i}-ary method */ + def capturingAll[${types_with_class_tags}](func: (${types}) => _): Seq[(${types})] = { + % for type in TYPE_VARS[:i]: + val argCaptor${type} = ArgumentCaptor.forClass(classTag[${type}].runtimeClass.asInstanceOf[Class[${type}]]) + % endfor + func(${', '.join("argCaptor{}.capture()".format(type) for type in TYPE_VARS[:i])}) + % for type in TYPE_VARS[:i]: + val args${type} = argCaptor${type}.getAllValues.asScala + % endfor + zipN(${', '.join("args{}".format(type) for type in TYPE_VARS[:i])}) + } + + /** Capture one invocation of a mocked ${i}-ary method */ + def capturingOne[${types_with_class_tags}](func: (${types}) => _): (${types}) = + capturingAll[${types}](func).lastOption.getOrElse(noArgWasCaptured()) + % endfor + +} diff --git a/project/Build.scala b/project/Build.scala index 08b3a9c71b..c9e0b3e061 100644 --- a/project/Build.scala +++ b/project/Build.scala @@ -300,7 +300,10 @@ object Util extends Build { sharedSettings ).settings( name := "util-test", - libraryDependencies += "org.scalatest" %% "scalatest" % "2.2.2" + libraryDependencies ++= Seq( + "org.scalatest" %% "scalatest" % "2.2.2", + "org.mockito" % "mockito-all" % "1.8.5" + ) ).dependsOn(utilCore, utilLogging) diff --git a/util-test/src/main/scala/BUILD b/util-test/src/main/scala/BUILD index 24e19e72ac..342297b3e0 100644 --- a/util-test/src/main/scala/BUILD +++ b/util-test/src/main/scala/BUILD @@ -5,6 +5,7 @@ scala_library(name='scala', repo = artifactory, ), dependencies=[ + '3rdparty/jvm/org/mockito:mockito-all', '3rdparty/jvm/org/scalatest', 'util/util-logging/src/main/scala', 'util/util-core/src/main/scala', diff --git a/util-test/src/main/scala/com/twitter/util/testing/ArgumentCapture.scala b/util-test/src/main/scala/com/twitter/util/testing/ArgumentCapture.scala new file mode 100644 index 0000000000..24123709c9 --- /dev/null +++ b/util-test/src/main/scala/com/twitter/util/testing/ArgumentCapture.scala @@ -0,0 +1,1134 @@ +package com.twitter.util.testing + +import java.util.{List => JList} +import org.mockito.ArgumentCaptor +import org.mockito.exceptions.Reporter +import scala.collection.JavaConverters._ +import scala.reflect._ + +// This file was generated from codegen/util-test/ArgumentCapture.scala.mako + +trait ArgumentCapture { + /** + * Enables capturingOne to be implemented over capturingAll with the same behavior as ArgumentCaptor.getValue + */ + private[this] def noArgWasCaptured(): Nothing = { + new Reporter().noArgumentValueWasCaptured() // this always throws an exception + throw new RuntimeException("this should be unreachable, but allows the method to be of type Nothing") + } + + /** + * Capture all the invocations from a verify(mock).method(arg) call. + * + * Example: + * val requests = capturingAll(verify(myAPIEndpoint, times(4)).authenticate _) + * requests.length must equal (4) + */ + def capturingAll[T: ClassTag](f: T => _): Seq[T] = { + val argCaptor = ArgumentCaptor.forClass(classTag[T].runtimeClass.asInstanceOf[Class[T]]) + f(argCaptor.capture()) + argCaptor.getAllValues.asScala.toSeq + } + + /** + * Capture an argument from a verify(mock).method(arg) call. + * + * Example: + * val request = capturingOne(verify(myAPIEndpoint).authenticate _) + * request.userId must equal (123L) + * request.password must equal ("reallySecurePassword") + */ + def capturingOne[T: ClassTag](f: T => _): T = + capturingAll[T](f).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 2 iterables together into a Seq of 2-tuples. */ + private[this] def zipN[A, B](arg0: Iterable[A], arg1: Iterable[B]): Seq[(A, B)] = { + arg0.zip(arg1).toSeq + } + + /** Capture all invocations of a mocked 2-ary method */ + def capturingAll[A: ClassTag, B: ClassTag](func: (A, B) => _): Seq[(A, B)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + func(argCaptorA.capture(), argCaptorB.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + zipN(argsA, argsB) + } + + /** Capture one invocation of a mocked 2-ary method */ + def capturingOne[A: ClassTag, B: ClassTag](func: (A, B) => _): (A, B) = + capturingAll[A, B](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 3 iterables together into a Seq of 3-tuples. */ + private[this] def zipN[A, B, C](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C]): Seq[(A, B, C)] = { + arg0 + .zip(arg1) + .zip(arg2) + .map({ case ((a, b), c) => (a, b, c) }) + .toSeq + } + + /** Capture all invocations of a mocked 3-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag](func: (A, B, C) => _): Seq[(A, B, C)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + zipN(argsA, argsB, argsC) + } + + /** Capture one invocation of a mocked 3-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag](func: (A, B, C) => _): (A, B, C) = + capturingAll[A, B, C](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 4 iterables together into a Seq of 4-tuples. */ + private[this] def zipN[A, B, C, D](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C], arg3: Iterable[D]): Seq[(A, B, C, D)] = { + arg0 + .zip(arg1) + .zip(arg2) + .zip(arg3) + .map({ case (((a, b), c), d) => (a, b, c, d) }) + .toSeq + } + + /** Capture all invocations of a mocked 4-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag](func: (A, B, C, D) => _): Seq[(A, B, C, D)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + val argCaptorD = ArgumentCaptor.forClass(classTag[D].runtimeClass.asInstanceOf[Class[D]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture(), argCaptorD.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + val argsD = argCaptorD.getAllValues.asScala + zipN(argsA, argsB, argsC, argsD) + } + + /** Capture one invocation of a mocked 4-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag](func: (A, B, C, D) => _): (A, B, C, D) = + capturingAll[A, B, C, D](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 5 iterables together into a Seq of 5-tuples. */ + private[this] def zipN[A, B, C, D, E](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C], arg3: Iterable[D], arg4: Iterable[E]): Seq[(A, B, C, D, E)] = { + arg0 + .zip(arg1) + .zip(arg2) + .zip(arg3) + .zip(arg4) + .map({ case ((((a, b), c), d), e) => (a, b, c, d, e) }) + .toSeq + } + + /** Capture all invocations of a mocked 5-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag](func: (A, B, C, D, E) => _): Seq[(A, B, C, D, E)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + val argCaptorD = ArgumentCaptor.forClass(classTag[D].runtimeClass.asInstanceOf[Class[D]]) + val argCaptorE = ArgumentCaptor.forClass(classTag[E].runtimeClass.asInstanceOf[Class[E]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture(), argCaptorD.capture(), argCaptorE.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + val argsD = argCaptorD.getAllValues.asScala + val argsE = argCaptorE.getAllValues.asScala + zipN(argsA, argsB, argsC, argsD, argsE) + } + + /** Capture one invocation of a mocked 5-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag](func: (A, B, C, D, E) => _): (A, B, C, D, E) = + capturingAll[A, B, C, D, E](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 6 iterables together into a Seq of 6-tuples. */ + private[this] def zipN[A, B, C, D, E, F](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C], arg3: Iterable[D], arg4: Iterable[E], arg5: Iterable[F]): Seq[(A, B, C, D, E, F)] = { + arg0 + .zip(arg1) + .zip(arg2) + .zip(arg3) + .zip(arg4) + .zip(arg5) + .map({ case (((((a, b), c), d), e), f) => (a, b, c, d, e, f) }) + .toSeq + } + + /** Capture all invocations of a mocked 6-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag](func: (A, B, C, D, E, F) => _): Seq[(A, B, C, D, E, F)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + val argCaptorD = ArgumentCaptor.forClass(classTag[D].runtimeClass.asInstanceOf[Class[D]]) + val argCaptorE = ArgumentCaptor.forClass(classTag[E].runtimeClass.asInstanceOf[Class[E]]) + val argCaptorF = ArgumentCaptor.forClass(classTag[F].runtimeClass.asInstanceOf[Class[F]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture(), argCaptorD.capture(), argCaptorE.capture(), argCaptorF.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + val argsD = argCaptorD.getAllValues.asScala + val argsE = argCaptorE.getAllValues.asScala + val argsF = argCaptorF.getAllValues.asScala + zipN(argsA, argsB, argsC, argsD, argsE, argsF) + } + + /** Capture one invocation of a mocked 6-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag](func: (A, B, C, D, E, F) => _): (A, B, C, D, E, F) = + capturingAll[A, B, C, D, E, F](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 7 iterables together into a Seq of 7-tuples. */ + private[this] def zipN[A, B, C, D, E, F, G](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C], arg3: Iterable[D], arg4: Iterable[E], arg5: Iterable[F], arg6: Iterable[G]): Seq[(A, B, C, D, E, F, G)] = { + arg0 + .zip(arg1) + .zip(arg2) + .zip(arg3) + .zip(arg4) + .zip(arg5) + .zip(arg6) + .map({ case ((((((a, b), c), d), e), f), g) => (a, b, c, d, e, f, g) }) + .toSeq + } + + /** Capture all invocations of a mocked 7-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag](func: (A, B, C, D, E, F, G) => _): Seq[(A, B, C, D, E, F, G)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + val argCaptorD = ArgumentCaptor.forClass(classTag[D].runtimeClass.asInstanceOf[Class[D]]) + val argCaptorE = ArgumentCaptor.forClass(classTag[E].runtimeClass.asInstanceOf[Class[E]]) + val argCaptorF = ArgumentCaptor.forClass(classTag[F].runtimeClass.asInstanceOf[Class[F]]) + val argCaptorG = ArgumentCaptor.forClass(classTag[G].runtimeClass.asInstanceOf[Class[G]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture(), argCaptorD.capture(), argCaptorE.capture(), argCaptorF.capture(), argCaptorG.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + val argsD = argCaptorD.getAllValues.asScala + val argsE = argCaptorE.getAllValues.asScala + val argsF = argCaptorF.getAllValues.asScala + val argsG = argCaptorG.getAllValues.asScala + zipN(argsA, argsB, argsC, argsD, argsE, argsF, argsG) + } + + /** Capture one invocation of a mocked 7-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag](func: (A, B, C, D, E, F, G) => _): (A, B, C, D, E, F, G) = + capturingAll[A, B, C, D, E, F, G](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 8 iterables together into a Seq of 8-tuples. */ + private[this] def zipN[A, B, C, D, E, F, G, H](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C], arg3: Iterable[D], arg4: Iterable[E], arg5: Iterable[F], arg6: Iterable[G], arg7: Iterable[H]): Seq[(A, B, C, D, E, F, G, H)] = { + arg0 + .zip(arg1) + .zip(arg2) + .zip(arg3) + .zip(arg4) + .zip(arg5) + .zip(arg6) + .zip(arg7) + .map({ case (((((((a, b), c), d), e), f), g), h) => (a, b, c, d, e, f, g, h) }) + .toSeq + } + + /** Capture all invocations of a mocked 8-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag](func: (A, B, C, D, E, F, G, H) => _): Seq[(A, B, C, D, E, F, G, H)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + val argCaptorD = ArgumentCaptor.forClass(classTag[D].runtimeClass.asInstanceOf[Class[D]]) + val argCaptorE = ArgumentCaptor.forClass(classTag[E].runtimeClass.asInstanceOf[Class[E]]) + val argCaptorF = ArgumentCaptor.forClass(classTag[F].runtimeClass.asInstanceOf[Class[F]]) + val argCaptorG = ArgumentCaptor.forClass(classTag[G].runtimeClass.asInstanceOf[Class[G]]) + val argCaptorH = ArgumentCaptor.forClass(classTag[H].runtimeClass.asInstanceOf[Class[H]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture(), argCaptorD.capture(), argCaptorE.capture(), argCaptorF.capture(), argCaptorG.capture(), argCaptorH.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + val argsD = argCaptorD.getAllValues.asScala + val argsE = argCaptorE.getAllValues.asScala + val argsF = argCaptorF.getAllValues.asScala + val argsG = argCaptorG.getAllValues.asScala + val argsH = argCaptorH.getAllValues.asScala + zipN(argsA, argsB, argsC, argsD, argsE, argsF, argsG, argsH) + } + + /** Capture one invocation of a mocked 8-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag](func: (A, B, C, D, E, F, G, H) => _): (A, B, C, D, E, F, G, H) = + capturingAll[A, B, C, D, E, F, G, H](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 9 iterables together into a Seq of 9-tuples. */ + private[this] def zipN[A, B, C, D, E, F, G, H, I](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C], arg3: Iterable[D], arg4: Iterable[E], arg5: Iterable[F], arg6: Iterable[G], arg7: Iterable[H], arg8: Iterable[I]): Seq[(A, B, C, D, E, F, G, H, I)] = { + arg0 + .zip(arg1) + .zip(arg2) + .zip(arg3) + .zip(arg4) + .zip(arg5) + .zip(arg6) + .zip(arg7) + .zip(arg8) + .map({ case ((((((((a, b), c), d), e), f), g), h), i) => (a, b, c, d, e, f, g, h, i) }) + .toSeq + } + + /** Capture all invocations of a mocked 9-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag](func: (A, B, C, D, E, F, G, H, I) => _): Seq[(A, B, C, D, E, F, G, H, I)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + val argCaptorD = ArgumentCaptor.forClass(classTag[D].runtimeClass.asInstanceOf[Class[D]]) + val argCaptorE = ArgumentCaptor.forClass(classTag[E].runtimeClass.asInstanceOf[Class[E]]) + val argCaptorF = ArgumentCaptor.forClass(classTag[F].runtimeClass.asInstanceOf[Class[F]]) + val argCaptorG = ArgumentCaptor.forClass(classTag[G].runtimeClass.asInstanceOf[Class[G]]) + val argCaptorH = ArgumentCaptor.forClass(classTag[H].runtimeClass.asInstanceOf[Class[H]]) + val argCaptorI = ArgumentCaptor.forClass(classTag[I].runtimeClass.asInstanceOf[Class[I]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture(), argCaptorD.capture(), argCaptorE.capture(), argCaptorF.capture(), argCaptorG.capture(), argCaptorH.capture(), argCaptorI.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + val argsD = argCaptorD.getAllValues.asScala + val argsE = argCaptorE.getAllValues.asScala + val argsF = argCaptorF.getAllValues.asScala + val argsG = argCaptorG.getAllValues.asScala + val argsH = argCaptorH.getAllValues.asScala + val argsI = argCaptorI.getAllValues.asScala + zipN(argsA, argsB, argsC, argsD, argsE, argsF, argsG, argsH, argsI) + } + + /** Capture one invocation of a mocked 9-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag](func: (A, B, C, D, E, F, G, H, I) => _): (A, B, C, D, E, F, G, H, I) = + capturingAll[A, B, C, D, E, F, G, H, I](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 10 iterables together into a Seq of 10-tuples. */ + private[this] def zipN[A, B, C, D, E, F, G, H, I, J](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C], arg3: Iterable[D], arg4: Iterable[E], arg5: Iterable[F], arg6: Iterable[G], arg7: Iterable[H], arg8: Iterable[I], arg9: Iterable[J]): Seq[(A, B, C, D, E, F, G, H, I, J)] = { + arg0 + .zip(arg1) + .zip(arg2) + .zip(arg3) + .zip(arg4) + .zip(arg5) + .zip(arg6) + .zip(arg7) + .zip(arg8) + .zip(arg9) + .map({ case (((((((((a, b), c), d), e), f), g), h), i), j) => (a, b, c, d, e, f, g, h, i, j) }) + .toSeq + } + + /** Capture all invocations of a mocked 10-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag](func: (A, B, C, D, E, F, G, H, I, J) => _): Seq[(A, B, C, D, E, F, G, H, I, J)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + val argCaptorD = ArgumentCaptor.forClass(classTag[D].runtimeClass.asInstanceOf[Class[D]]) + val argCaptorE = ArgumentCaptor.forClass(classTag[E].runtimeClass.asInstanceOf[Class[E]]) + val argCaptorF = ArgumentCaptor.forClass(classTag[F].runtimeClass.asInstanceOf[Class[F]]) + val argCaptorG = ArgumentCaptor.forClass(classTag[G].runtimeClass.asInstanceOf[Class[G]]) + val argCaptorH = ArgumentCaptor.forClass(classTag[H].runtimeClass.asInstanceOf[Class[H]]) + val argCaptorI = ArgumentCaptor.forClass(classTag[I].runtimeClass.asInstanceOf[Class[I]]) + val argCaptorJ = ArgumentCaptor.forClass(classTag[J].runtimeClass.asInstanceOf[Class[J]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture(), argCaptorD.capture(), argCaptorE.capture(), argCaptorF.capture(), argCaptorG.capture(), argCaptorH.capture(), argCaptorI.capture(), argCaptorJ.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + val argsD = argCaptorD.getAllValues.asScala + val argsE = argCaptorE.getAllValues.asScala + val argsF = argCaptorF.getAllValues.asScala + val argsG = argCaptorG.getAllValues.asScala + val argsH = argCaptorH.getAllValues.asScala + val argsI = argCaptorI.getAllValues.asScala + val argsJ = argCaptorJ.getAllValues.asScala + zipN(argsA, argsB, argsC, argsD, argsE, argsF, argsG, argsH, argsI, argsJ) + } + + /** Capture one invocation of a mocked 10-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag](func: (A, B, C, D, E, F, G, H, I, J) => _): (A, B, C, D, E, F, G, H, I, J) = + capturingAll[A, B, C, D, E, F, G, H, I, J](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 11 iterables together into a Seq of 11-tuples. */ + private[this] def zipN[A, B, C, D, E, F, G, H, I, J, K](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C], arg3: Iterable[D], arg4: Iterable[E], arg5: Iterable[F], arg6: Iterable[G], arg7: Iterable[H], arg8: Iterable[I], arg9: Iterable[J], arg10: Iterable[K]): Seq[(A, B, C, D, E, F, G, H, I, J, K)] = { + arg0 + .zip(arg1) + .zip(arg2) + .zip(arg3) + .zip(arg4) + .zip(arg5) + .zip(arg6) + .zip(arg7) + .zip(arg8) + .zip(arg9) + .zip(arg10) + .map({ case ((((((((((a, b), c), d), e), f), g), h), i), j), k) => (a, b, c, d, e, f, g, h, i, j, k) }) + .toSeq + } + + /** Capture all invocations of a mocked 11-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K) => _): Seq[(A, B, C, D, E, F, G, H, I, J, K)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + val argCaptorD = ArgumentCaptor.forClass(classTag[D].runtimeClass.asInstanceOf[Class[D]]) + val argCaptorE = ArgumentCaptor.forClass(classTag[E].runtimeClass.asInstanceOf[Class[E]]) + val argCaptorF = ArgumentCaptor.forClass(classTag[F].runtimeClass.asInstanceOf[Class[F]]) + val argCaptorG = ArgumentCaptor.forClass(classTag[G].runtimeClass.asInstanceOf[Class[G]]) + val argCaptorH = ArgumentCaptor.forClass(classTag[H].runtimeClass.asInstanceOf[Class[H]]) + val argCaptorI = ArgumentCaptor.forClass(classTag[I].runtimeClass.asInstanceOf[Class[I]]) + val argCaptorJ = ArgumentCaptor.forClass(classTag[J].runtimeClass.asInstanceOf[Class[J]]) + val argCaptorK = ArgumentCaptor.forClass(classTag[K].runtimeClass.asInstanceOf[Class[K]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture(), argCaptorD.capture(), argCaptorE.capture(), argCaptorF.capture(), argCaptorG.capture(), argCaptorH.capture(), argCaptorI.capture(), argCaptorJ.capture(), argCaptorK.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + val argsD = argCaptorD.getAllValues.asScala + val argsE = argCaptorE.getAllValues.asScala + val argsF = argCaptorF.getAllValues.asScala + val argsG = argCaptorG.getAllValues.asScala + val argsH = argCaptorH.getAllValues.asScala + val argsI = argCaptorI.getAllValues.asScala + val argsJ = argCaptorJ.getAllValues.asScala + val argsK = argCaptorK.getAllValues.asScala + zipN(argsA, argsB, argsC, argsD, argsE, argsF, argsG, argsH, argsI, argsJ, argsK) + } + + /** Capture one invocation of a mocked 11-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K) => _): (A, B, C, D, E, F, G, H, I, J, K) = + capturingAll[A, B, C, D, E, F, G, H, I, J, K](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 12 iterables together into a Seq of 12-tuples. */ + private[this] def zipN[A, B, C, D, E, F, G, H, I, J, K, L](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C], arg3: Iterable[D], arg4: Iterable[E], arg5: Iterable[F], arg6: Iterable[G], arg7: Iterable[H], arg8: Iterable[I], arg9: Iterable[J], arg10: Iterable[K], arg11: Iterable[L]): Seq[(A, B, C, D, E, F, G, H, I, J, K, L)] = { + arg0 + .zip(arg1) + .zip(arg2) + .zip(arg3) + .zip(arg4) + .zip(arg5) + .zip(arg6) + .zip(arg7) + .zip(arg8) + .zip(arg9) + .zip(arg10) + .zip(arg11) + .map({ case (((((((((((a, b), c), d), e), f), g), h), i), j), k), l) => (a, b, c, d, e, f, g, h, i, j, k, l) }) + .toSeq + } + + /** Capture all invocations of a mocked 12-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L) => _): Seq[(A, B, C, D, E, F, G, H, I, J, K, L)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + val argCaptorD = ArgumentCaptor.forClass(classTag[D].runtimeClass.asInstanceOf[Class[D]]) + val argCaptorE = ArgumentCaptor.forClass(classTag[E].runtimeClass.asInstanceOf[Class[E]]) + val argCaptorF = ArgumentCaptor.forClass(classTag[F].runtimeClass.asInstanceOf[Class[F]]) + val argCaptorG = ArgumentCaptor.forClass(classTag[G].runtimeClass.asInstanceOf[Class[G]]) + val argCaptorH = ArgumentCaptor.forClass(classTag[H].runtimeClass.asInstanceOf[Class[H]]) + val argCaptorI = ArgumentCaptor.forClass(classTag[I].runtimeClass.asInstanceOf[Class[I]]) + val argCaptorJ = ArgumentCaptor.forClass(classTag[J].runtimeClass.asInstanceOf[Class[J]]) + val argCaptorK = ArgumentCaptor.forClass(classTag[K].runtimeClass.asInstanceOf[Class[K]]) + val argCaptorL = ArgumentCaptor.forClass(classTag[L].runtimeClass.asInstanceOf[Class[L]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture(), argCaptorD.capture(), argCaptorE.capture(), argCaptorF.capture(), argCaptorG.capture(), argCaptorH.capture(), argCaptorI.capture(), argCaptorJ.capture(), argCaptorK.capture(), argCaptorL.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + val argsD = argCaptorD.getAllValues.asScala + val argsE = argCaptorE.getAllValues.asScala + val argsF = argCaptorF.getAllValues.asScala + val argsG = argCaptorG.getAllValues.asScala + val argsH = argCaptorH.getAllValues.asScala + val argsI = argCaptorI.getAllValues.asScala + val argsJ = argCaptorJ.getAllValues.asScala + val argsK = argCaptorK.getAllValues.asScala + val argsL = argCaptorL.getAllValues.asScala + zipN(argsA, argsB, argsC, argsD, argsE, argsF, argsG, argsH, argsI, argsJ, argsK, argsL) + } + + /** Capture one invocation of a mocked 12-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L) => _): (A, B, C, D, E, F, G, H, I, J, K, L) = + capturingAll[A, B, C, D, E, F, G, H, I, J, K, L](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 13 iterables together into a Seq of 13-tuples. */ + private[this] def zipN[A, B, C, D, E, F, G, H, I, J, K, L, M](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C], arg3: Iterable[D], arg4: Iterable[E], arg5: Iterable[F], arg6: Iterable[G], arg7: Iterable[H], arg8: Iterable[I], arg9: Iterable[J], arg10: Iterable[K], arg11: Iterable[L], arg12: Iterable[M]): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M)] = { + arg0 + .zip(arg1) + .zip(arg2) + .zip(arg3) + .zip(arg4) + .zip(arg5) + .zip(arg6) + .zip(arg7) + .zip(arg8) + .zip(arg9) + .zip(arg10) + .zip(arg11) + .zip(arg12) + .map({ case ((((((((((((a, b), c), d), e), f), g), h), i), j), k), l), m) => (a, b, c, d, e, f, g, h, i, j, k, l, m) }) + .toSeq + } + + /** Capture all invocations of a mocked 13-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M) => _): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + val argCaptorD = ArgumentCaptor.forClass(classTag[D].runtimeClass.asInstanceOf[Class[D]]) + val argCaptorE = ArgumentCaptor.forClass(classTag[E].runtimeClass.asInstanceOf[Class[E]]) + val argCaptorF = ArgumentCaptor.forClass(classTag[F].runtimeClass.asInstanceOf[Class[F]]) + val argCaptorG = ArgumentCaptor.forClass(classTag[G].runtimeClass.asInstanceOf[Class[G]]) + val argCaptorH = ArgumentCaptor.forClass(classTag[H].runtimeClass.asInstanceOf[Class[H]]) + val argCaptorI = ArgumentCaptor.forClass(classTag[I].runtimeClass.asInstanceOf[Class[I]]) + val argCaptorJ = ArgumentCaptor.forClass(classTag[J].runtimeClass.asInstanceOf[Class[J]]) + val argCaptorK = ArgumentCaptor.forClass(classTag[K].runtimeClass.asInstanceOf[Class[K]]) + val argCaptorL = ArgumentCaptor.forClass(classTag[L].runtimeClass.asInstanceOf[Class[L]]) + val argCaptorM = ArgumentCaptor.forClass(classTag[M].runtimeClass.asInstanceOf[Class[M]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture(), argCaptorD.capture(), argCaptorE.capture(), argCaptorF.capture(), argCaptorG.capture(), argCaptorH.capture(), argCaptorI.capture(), argCaptorJ.capture(), argCaptorK.capture(), argCaptorL.capture(), argCaptorM.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + val argsD = argCaptorD.getAllValues.asScala + val argsE = argCaptorE.getAllValues.asScala + val argsF = argCaptorF.getAllValues.asScala + val argsG = argCaptorG.getAllValues.asScala + val argsH = argCaptorH.getAllValues.asScala + val argsI = argCaptorI.getAllValues.asScala + val argsJ = argCaptorJ.getAllValues.asScala + val argsK = argCaptorK.getAllValues.asScala + val argsL = argCaptorL.getAllValues.asScala + val argsM = argCaptorM.getAllValues.asScala + zipN(argsA, argsB, argsC, argsD, argsE, argsF, argsG, argsH, argsI, argsJ, argsK, argsL, argsM) + } + + /** Capture one invocation of a mocked 13-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M) => _): (A, B, C, D, E, F, G, H, I, J, K, L, M) = + capturingAll[A, B, C, D, E, F, G, H, I, J, K, L, M](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 14 iterables together into a Seq of 14-tuples. */ + private[this] def zipN[A, B, C, D, E, F, G, H, I, J, K, L, M, N](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C], arg3: Iterable[D], arg4: Iterable[E], arg5: Iterable[F], arg6: Iterable[G], arg7: Iterable[H], arg8: Iterable[I], arg9: Iterable[J], arg10: Iterable[K], arg11: Iterable[L], arg12: Iterable[M], arg13: Iterable[N]): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] = { + arg0 + .zip(arg1) + .zip(arg2) + .zip(arg3) + .zip(arg4) + .zip(arg5) + .zip(arg6) + .zip(arg7) + .zip(arg8) + .zip(arg9) + .zip(arg10) + .zip(arg11) + .zip(arg12) + .zip(arg13) + .map({ case (((((((((((((a, b), c), d), e), f), g), h), i), j), k), l), m), n) => (a, b, c, d, e, f, g, h, i, j, k, l, m, n) }) + .toSeq + } + + /** Capture all invocations of a mocked 14-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag, N: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => _): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + val argCaptorD = ArgumentCaptor.forClass(classTag[D].runtimeClass.asInstanceOf[Class[D]]) + val argCaptorE = ArgumentCaptor.forClass(classTag[E].runtimeClass.asInstanceOf[Class[E]]) + val argCaptorF = ArgumentCaptor.forClass(classTag[F].runtimeClass.asInstanceOf[Class[F]]) + val argCaptorG = ArgumentCaptor.forClass(classTag[G].runtimeClass.asInstanceOf[Class[G]]) + val argCaptorH = ArgumentCaptor.forClass(classTag[H].runtimeClass.asInstanceOf[Class[H]]) + val argCaptorI = ArgumentCaptor.forClass(classTag[I].runtimeClass.asInstanceOf[Class[I]]) + val argCaptorJ = ArgumentCaptor.forClass(classTag[J].runtimeClass.asInstanceOf[Class[J]]) + val argCaptorK = ArgumentCaptor.forClass(classTag[K].runtimeClass.asInstanceOf[Class[K]]) + val argCaptorL = ArgumentCaptor.forClass(classTag[L].runtimeClass.asInstanceOf[Class[L]]) + val argCaptorM = ArgumentCaptor.forClass(classTag[M].runtimeClass.asInstanceOf[Class[M]]) + val argCaptorN = ArgumentCaptor.forClass(classTag[N].runtimeClass.asInstanceOf[Class[N]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture(), argCaptorD.capture(), argCaptorE.capture(), argCaptorF.capture(), argCaptorG.capture(), argCaptorH.capture(), argCaptorI.capture(), argCaptorJ.capture(), argCaptorK.capture(), argCaptorL.capture(), argCaptorM.capture(), argCaptorN.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + val argsD = argCaptorD.getAllValues.asScala + val argsE = argCaptorE.getAllValues.asScala + val argsF = argCaptorF.getAllValues.asScala + val argsG = argCaptorG.getAllValues.asScala + val argsH = argCaptorH.getAllValues.asScala + val argsI = argCaptorI.getAllValues.asScala + val argsJ = argCaptorJ.getAllValues.asScala + val argsK = argCaptorK.getAllValues.asScala + val argsL = argCaptorL.getAllValues.asScala + val argsM = argCaptorM.getAllValues.asScala + val argsN = argCaptorN.getAllValues.asScala + zipN(argsA, argsB, argsC, argsD, argsE, argsF, argsG, argsH, argsI, argsJ, argsK, argsL, argsM, argsN) + } + + /** Capture one invocation of a mocked 14-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag, N: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => _): (A, B, C, D, E, F, G, H, I, J, K, L, M, N) = + capturingAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 15 iterables together into a Seq of 15-tuples. */ + private[this] def zipN[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C], arg3: Iterable[D], arg4: Iterable[E], arg5: Iterable[F], arg6: Iterable[G], arg7: Iterable[H], arg8: Iterable[I], arg9: Iterable[J], arg10: Iterable[K], arg11: Iterable[L], arg12: Iterable[M], arg13: Iterable[N], arg14: Iterable[O]): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] = { + arg0 + .zip(arg1) + .zip(arg2) + .zip(arg3) + .zip(arg4) + .zip(arg5) + .zip(arg6) + .zip(arg7) + .zip(arg8) + .zip(arg9) + .zip(arg10) + .zip(arg11) + .zip(arg12) + .zip(arg13) + .zip(arg14) + .map({ case ((((((((((((((a, b), c), d), e), f), g), h), i), j), k), l), m), n), o) => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) }) + .toSeq + } + + /** Capture all invocations of a mocked 15-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag, N: ClassTag, O: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => _): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + val argCaptorD = ArgumentCaptor.forClass(classTag[D].runtimeClass.asInstanceOf[Class[D]]) + val argCaptorE = ArgumentCaptor.forClass(classTag[E].runtimeClass.asInstanceOf[Class[E]]) + val argCaptorF = ArgumentCaptor.forClass(classTag[F].runtimeClass.asInstanceOf[Class[F]]) + val argCaptorG = ArgumentCaptor.forClass(classTag[G].runtimeClass.asInstanceOf[Class[G]]) + val argCaptorH = ArgumentCaptor.forClass(classTag[H].runtimeClass.asInstanceOf[Class[H]]) + val argCaptorI = ArgumentCaptor.forClass(classTag[I].runtimeClass.asInstanceOf[Class[I]]) + val argCaptorJ = ArgumentCaptor.forClass(classTag[J].runtimeClass.asInstanceOf[Class[J]]) + val argCaptorK = ArgumentCaptor.forClass(classTag[K].runtimeClass.asInstanceOf[Class[K]]) + val argCaptorL = ArgumentCaptor.forClass(classTag[L].runtimeClass.asInstanceOf[Class[L]]) + val argCaptorM = ArgumentCaptor.forClass(classTag[M].runtimeClass.asInstanceOf[Class[M]]) + val argCaptorN = ArgumentCaptor.forClass(classTag[N].runtimeClass.asInstanceOf[Class[N]]) + val argCaptorO = ArgumentCaptor.forClass(classTag[O].runtimeClass.asInstanceOf[Class[O]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture(), argCaptorD.capture(), argCaptorE.capture(), argCaptorF.capture(), argCaptorG.capture(), argCaptorH.capture(), argCaptorI.capture(), argCaptorJ.capture(), argCaptorK.capture(), argCaptorL.capture(), argCaptorM.capture(), argCaptorN.capture(), argCaptorO.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + val argsD = argCaptorD.getAllValues.asScala + val argsE = argCaptorE.getAllValues.asScala + val argsF = argCaptorF.getAllValues.asScala + val argsG = argCaptorG.getAllValues.asScala + val argsH = argCaptorH.getAllValues.asScala + val argsI = argCaptorI.getAllValues.asScala + val argsJ = argCaptorJ.getAllValues.asScala + val argsK = argCaptorK.getAllValues.asScala + val argsL = argCaptorL.getAllValues.asScala + val argsM = argCaptorM.getAllValues.asScala + val argsN = argCaptorN.getAllValues.asScala + val argsO = argCaptorO.getAllValues.asScala + zipN(argsA, argsB, argsC, argsD, argsE, argsF, argsG, argsH, argsI, argsJ, argsK, argsL, argsM, argsN, argsO) + } + + /** Capture one invocation of a mocked 15-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag, N: ClassTag, O: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => _): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) = + capturingAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 16 iterables together into a Seq of 16-tuples. */ + private[this] def zipN[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C], arg3: Iterable[D], arg4: Iterable[E], arg5: Iterable[F], arg6: Iterable[G], arg7: Iterable[H], arg8: Iterable[I], arg9: Iterable[J], arg10: Iterable[K], arg11: Iterable[L], arg12: Iterable[M], arg13: Iterable[N], arg14: Iterable[O], arg15: Iterable[P]): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] = { + arg0 + .zip(arg1) + .zip(arg2) + .zip(arg3) + .zip(arg4) + .zip(arg5) + .zip(arg6) + .zip(arg7) + .zip(arg8) + .zip(arg9) + .zip(arg10) + .zip(arg11) + .zip(arg12) + .zip(arg13) + .zip(arg14) + .zip(arg15) + .map({ case (((((((((((((((a, b), c), d), e), f), g), h), i), j), k), l), m), n), o), p) => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) }) + .toSeq + } + + /** Capture all invocations of a mocked 16-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag, N: ClassTag, O: ClassTag, P: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => _): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + val argCaptorD = ArgumentCaptor.forClass(classTag[D].runtimeClass.asInstanceOf[Class[D]]) + val argCaptorE = ArgumentCaptor.forClass(classTag[E].runtimeClass.asInstanceOf[Class[E]]) + val argCaptorF = ArgumentCaptor.forClass(classTag[F].runtimeClass.asInstanceOf[Class[F]]) + val argCaptorG = ArgumentCaptor.forClass(classTag[G].runtimeClass.asInstanceOf[Class[G]]) + val argCaptorH = ArgumentCaptor.forClass(classTag[H].runtimeClass.asInstanceOf[Class[H]]) + val argCaptorI = ArgumentCaptor.forClass(classTag[I].runtimeClass.asInstanceOf[Class[I]]) + val argCaptorJ = ArgumentCaptor.forClass(classTag[J].runtimeClass.asInstanceOf[Class[J]]) + val argCaptorK = ArgumentCaptor.forClass(classTag[K].runtimeClass.asInstanceOf[Class[K]]) + val argCaptorL = ArgumentCaptor.forClass(classTag[L].runtimeClass.asInstanceOf[Class[L]]) + val argCaptorM = ArgumentCaptor.forClass(classTag[M].runtimeClass.asInstanceOf[Class[M]]) + val argCaptorN = ArgumentCaptor.forClass(classTag[N].runtimeClass.asInstanceOf[Class[N]]) + val argCaptorO = ArgumentCaptor.forClass(classTag[O].runtimeClass.asInstanceOf[Class[O]]) + val argCaptorP = ArgumentCaptor.forClass(classTag[P].runtimeClass.asInstanceOf[Class[P]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture(), argCaptorD.capture(), argCaptorE.capture(), argCaptorF.capture(), argCaptorG.capture(), argCaptorH.capture(), argCaptorI.capture(), argCaptorJ.capture(), argCaptorK.capture(), argCaptorL.capture(), argCaptorM.capture(), argCaptorN.capture(), argCaptorO.capture(), argCaptorP.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + val argsD = argCaptorD.getAllValues.asScala + val argsE = argCaptorE.getAllValues.asScala + val argsF = argCaptorF.getAllValues.asScala + val argsG = argCaptorG.getAllValues.asScala + val argsH = argCaptorH.getAllValues.asScala + val argsI = argCaptorI.getAllValues.asScala + val argsJ = argCaptorJ.getAllValues.asScala + val argsK = argCaptorK.getAllValues.asScala + val argsL = argCaptorL.getAllValues.asScala + val argsM = argCaptorM.getAllValues.asScala + val argsN = argCaptorN.getAllValues.asScala + val argsO = argCaptorO.getAllValues.asScala + val argsP = argCaptorP.getAllValues.asScala + zipN(argsA, argsB, argsC, argsD, argsE, argsF, argsG, argsH, argsI, argsJ, argsK, argsL, argsM, argsN, argsO, argsP) + } + + /** Capture one invocation of a mocked 16-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag, N: ClassTag, O: ClassTag, P: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => _): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) = + capturingAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 17 iterables together into a Seq of 17-tuples. */ + private[this] def zipN[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C], arg3: Iterable[D], arg4: Iterable[E], arg5: Iterable[F], arg6: Iterable[G], arg7: Iterable[H], arg8: Iterable[I], arg9: Iterable[J], arg10: Iterable[K], arg11: Iterable[L], arg12: Iterable[M], arg13: Iterable[N], arg14: Iterable[O], arg15: Iterable[P], arg16: Iterable[Q]): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] = { + arg0 + .zip(arg1) + .zip(arg2) + .zip(arg3) + .zip(arg4) + .zip(arg5) + .zip(arg6) + .zip(arg7) + .zip(arg8) + .zip(arg9) + .zip(arg10) + .zip(arg11) + .zip(arg12) + .zip(arg13) + .zip(arg14) + .zip(arg15) + .zip(arg16) + .map({ case ((((((((((((((((a, b), c), d), e), f), g), h), i), j), k), l), m), n), o), p), q) => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) }) + .toSeq + } + + /** Capture all invocations of a mocked 17-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag, N: ClassTag, O: ClassTag, P: ClassTag, Q: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => _): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + val argCaptorD = ArgumentCaptor.forClass(classTag[D].runtimeClass.asInstanceOf[Class[D]]) + val argCaptorE = ArgumentCaptor.forClass(classTag[E].runtimeClass.asInstanceOf[Class[E]]) + val argCaptorF = ArgumentCaptor.forClass(classTag[F].runtimeClass.asInstanceOf[Class[F]]) + val argCaptorG = ArgumentCaptor.forClass(classTag[G].runtimeClass.asInstanceOf[Class[G]]) + val argCaptorH = ArgumentCaptor.forClass(classTag[H].runtimeClass.asInstanceOf[Class[H]]) + val argCaptorI = ArgumentCaptor.forClass(classTag[I].runtimeClass.asInstanceOf[Class[I]]) + val argCaptorJ = ArgumentCaptor.forClass(classTag[J].runtimeClass.asInstanceOf[Class[J]]) + val argCaptorK = ArgumentCaptor.forClass(classTag[K].runtimeClass.asInstanceOf[Class[K]]) + val argCaptorL = ArgumentCaptor.forClass(classTag[L].runtimeClass.asInstanceOf[Class[L]]) + val argCaptorM = ArgumentCaptor.forClass(classTag[M].runtimeClass.asInstanceOf[Class[M]]) + val argCaptorN = ArgumentCaptor.forClass(classTag[N].runtimeClass.asInstanceOf[Class[N]]) + val argCaptorO = ArgumentCaptor.forClass(classTag[O].runtimeClass.asInstanceOf[Class[O]]) + val argCaptorP = ArgumentCaptor.forClass(classTag[P].runtimeClass.asInstanceOf[Class[P]]) + val argCaptorQ = ArgumentCaptor.forClass(classTag[Q].runtimeClass.asInstanceOf[Class[Q]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture(), argCaptorD.capture(), argCaptorE.capture(), argCaptorF.capture(), argCaptorG.capture(), argCaptorH.capture(), argCaptorI.capture(), argCaptorJ.capture(), argCaptorK.capture(), argCaptorL.capture(), argCaptorM.capture(), argCaptorN.capture(), argCaptorO.capture(), argCaptorP.capture(), argCaptorQ.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + val argsD = argCaptorD.getAllValues.asScala + val argsE = argCaptorE.getAllValues.asScala + val argsF = argCaptorF.getAllValues.asScala + val argsG = argCaptorG.getAllValues.asScala + val argsH = argCaptorH.getAllValues.asScala + val argsI = argCaptorI.getAllValues.asScala + val argsJ = argCaptorJ.getAllValues.asScala + val argsK = argCaptorK.getAllValues.asScala + val argsL = argCaptorL.getAllValues.asScala + val argsM = argCaptorM.getAllValues.asScala + val argsN = argCaptorN.getAllValues.asScala + val argsO = argCaptorO.getAllValues.asScala + val argsP = argCaptorP.getAllValues.asScala + val argsQ = argCaptorQ.getAllValues.asScala + zipN(argsA, argsB, argsC, argsD, argsE, argsF, argsG, argsH, argsI, argsJ, argsK, argsL, argsM, argsN, argsO, argsP, argsQ) + } + + /** Capture one invocation of a mocked 17-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag, N: ClassTag, O: ClassTag, P: ClassTag, Q: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => _): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) = + capturingAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 18 iterables together into a Seq of 18-tuples. */ + private[this] def zipN[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C], arg3: Iterable[D], arg4: Iterable[E], arg5: Iterable[F], arg6: Iterable[G], arg7: Iterable[H], arg8: Iterable[I], arg9: Iterable[J], arg10: Iterable[K], arg11: Iterable[L], arg12: Iterable[M], arg13: Iterable[N], arg14: Iterable[O], arg15: Iterable[P], arg16: Iterable[Q], arg17: Iterable[R]): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] = { + arg0 + .zip(arg1) + .zip(arg2) + .zip(arg3) + .zip(arg4) + .zip(arg5) + .zip(arg6) + .zip(arg7) + .zip(arg8) + .zip(arg9) + .zip(arg10) + .zip(arg11) + .zip(arg12) + .zip(arg13) + .zip(arg14) + .zip(arg15) + .zip(arg16) + .zip(arg17) + .map({ case (((((((((((((((((a, b), c), d), e), f), g), h), i), j), k), l), m), n), o), p), q), r) => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) }) + .toSeq + } + + /** Capture all invocations of a mocked 18-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag, N: ClassTag, O: ClassTag, P: ClassTag, Q: ClassTag, R: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => _): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + val argCaptorD = ArgumentCaptor.forClass(classTag[D].runtimeClass.asInstanceOf[Class[D]]) + val argCaptorE = ArgumentCaptor.forClass(classTag[E].runtimeClass.asInstanceOf[Class[E]]) + val argCaptorF = ArgumentCaptor.forClass(classTag[F].runtimeClass.asInstanceOf[Class[F]]) + val argCaptorG = ArgumentCaptor.forClass(classTag[G].runtimeClass.asInstanceOf[Class[G]]) + val argCaptorH = ArgumentCaptor.forClass(classTag[H].runtimeClass.asInstanceOf[Class[H]]) + val argCaptorI = ArgumentCaptor.forClass(classTag[I].runtimeClass.asInstanceOf[Class[I]]) + val argCaptorJ = ArgumentCaptor.forClass(classTag[J].runtimeClass.asInstanceOf[Class[J]]) + val argCaptorK = ArgumentCaptor.forClass(classTag[K].runtimeClass.asInstanceOf[Class[K]]) + val argCaptorL = ArgumentCaptor.forClass(classTag[L].runtimeClass.asInstanceOf[Class[L]]) + val argCaptorM = ArgumentCaptor.forClass(classTag[M].runtimeClass.asInstanceOf[Class[M]]) + val argCaptorN = ArgumentCaptor.forClass(classTag[N].runtimeClass.asInstanceOf[Class[N]]) + val argCaptorO = ArgumentCaptor.forClass(classTag[O].runtimeClass.asInstanceOf[Class[O]]) + val argCaptorP = ArgumentCaptor.forClass(classTag[P].runtimeClass.asInstanceOf[Class[P]]) + val argCaptorQ = ArgumentCaptor.forClass(classTag[Q].runtimeClass.asInstanceOf[Class[Q]]) + val argCaptorR = ArgumentCaptor.forClass(classTag[R].runtimeClass.asInstanceOf[Class[R]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture(), argCaptorD.capture(), argCaptorE.capture(), argCaptorF.capture(), argCaptorG.capture(), argCaptorH.capture(), argCaptorI.capture(), argCaptorJ.capture(), argCaptorK.capture(), argCaptorL.capture(), argCaptorM.capture(), argCaptorN.capture(), argCaptorO.capture(), argCaptorP.capture(), argCaptorQ.capture(), argCaptorR.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + val argsD = argCaptorD.getAllValues.asScala + val argsE = argCaptorE.getAllValues.asScala + val argsF = argCaptorF.getAllValues.asScala + val argsG = argCaptorG.getAllValues.asScala + val argsH = argCaptorH.getAllValues.asScala + val argsI = argCaptorI.getAllValues.asScala + val argsJ = argCaptorJ.getAllValues.asScala + val argsK = argCaptorK.getAllValues.asScala + val argsL = argCaptorL.getAllValues.asScala + val argsM = argCaptorM.getAllValues.asScala + val argsN = argCaptorN.getAllValues.asScala + val argsO = argCaptorO.getAllValues.asScala + val argsP = argCaptorP.getAllValues.asScala + val argsQ = argCaptorQ.getAllValues.asScala + val argsR = argCaptorR.getAllValues.asScala + zipN(argsA, argsB, argsC, argsD, argsE, argsF, argsG, argsH, argsI, argsJ, argsK, argsL, argsM, argsN, argsO, argsP, argsQ, argsR) + } + + /** Capture one invocation of a mocked 18-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag, N: ClassTag, O: ClassTag, P: ClassTag, Q: ClassTag, R: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => _): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) = + capturingAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 19 iterables together into a Seq of 19-tuples. */ + private[this] def zipN[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C], arg3: Iterable[D], arg4: Iterable[E], arg5: Iterable[F], arg6: Iterable[G], arg7: Iterable[H], arg8: Iterable[I], arg9: Iterable[J], arg10: Iterable[K], arg11: Iterable[L], arg12: Iterable[M], arg13: Iterable[N], arg14: Iterable[O], arg15: Iterable[P], arg16: Iterable[Q], arg17: Iterable[R], arg18: Iterable[S]): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] = { + arg0 + .zip(arg1) + .zip(arg2) + .zip(arg3) + .zip(arg4) + .zip(arg5) + .zip(arg6) + .zip(arg7) + .zip(arg8) + .zip(arg9) + .zip(arg10) + .zip(arg11) + .zip(arg12) + .zip(arg13) + .zip(arg14) + .zip(arg15) + .zip(arg16) + .zip(arg17) + .zip(arg18) + .map({ case ((((((((((((((((((a, b), c), d), e), f), g), h), i), j), k), l), m), n), o), p), q), r), s) => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) }) + .toSeq + } + + /** Capture all invocations of a mocked 19-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag, N: ClassTag, O: ClassTag, P: ClassTag, Q: ClassTag, R: ClassTag, S: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => _): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + val argCaptorD = ArgumentCaptor.forClass(classTag[D].runtimeClass.asInstanceOf[Class[D]]) + val argCaptorE = ArgumentCaptor.forClass(classTag[E].runtimeClass.asInstanceOf[Class[E]]) + val argCaptorF = ArgumentCaptor.forClass(classTag[F].runtimeClass.asInstanceOf[Class[F]]) + val argCaptorG = ArgumentCaptor.forClass(classTag[G].runtimeClass.asInstanceOf[Class[G]]) + val argCaptorH = ArgumentCaptor.forClass(classTag[H].runtimeClass.asInstanceOf[Class[H]]) + val argCaptorI = ArgumentCaptor.forClass(classTag[I].runtimeClass.asInstanceOf[Class[I]]) + val argCaptorJ = ArgumentCaptor.forClass(classTag[J].runtimeClass.asInstanceOf[Class[J]]) + val argCaptorK = ArgumentCaptor.forClass(classTag[K].runtimeClass.asInstanceOf[Class[K]]) + val argCaptorL = ArgumentCaptor.forClass(classTag[L].runtimeClass.asInstanceOf[Class[L]]) + val argCaptorM = ArgumentCaptor.forClass(classTag[M].runtimeClass.asInstanceOf[Class[M]]) + val argCaptorN = ArgumentCaptor.forClass(classTag[N].runtimeClass.asInstanceOf[Class[N]]) + val argCaptorO = ArgumentCaptor.forClass(classTag[O].runtimeClass.asInstanceOf[Class[O]]) + val argCaptorP = ArgumentCaptor.forClass(classTag[P].runtimeClass.asInstanceOf[Class[P]]) + val argCaptorQ = ArgumentCaptor.forClass(classTag[Q].runtimeClass.asInstanceOf[Class[Q]]) + val argCaptorR = ArgumentCaptor.forClass(classTag[R].runtimeClass.asInstanceOf[Class[R]]) + val argCaptorS = ArgumentCaptor.forClass(classTag[S].runtimeClass.asInstanceOf[Class[S]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture(), argCaptorD.capture(), argCaptorE.capture(), argCaptorF.capture(), argCaptorG.capture(), argCaptorH.capture(), argCaptorI.capture(), argCaptorJ.capture(), argCaptorK.capture(), argCaptorL.capture(), argCaptorM.capture(), argCaptorN.capture(), argCaptorO.capture(), argCaptorP.capture(), argCaptorQ.capture(), argCaptorR.capture(), argCaptorS.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + val argsD = argCaptorD.getAllValues.asScala + val argsE = argCaptorE.getAllValues.asScala + val argsF = argCaptorF.getAllValues.asScala + val argsG = argCaptorG.getAllValues.asScala + val argsH = argCaptorH.getAllValues.asScala + val argsI = argCaptorI.getAllValues.asScala + val argsJ = argCaptorJ.getAllValues.asScala + val argsK = argCaptorK.getAllValues.asScala + val argsL = argCaptorL.getAllValues.asScala + val argsM = argCaptorM.getAllValues.asScala + val argsN = argCaptorN.getAllValues.asScala + val argsO = argCaptorO.getAllValues.asScala + val argsP = argCaptorP.getAllValues.asScala + val argsQ = argCaptorQ.getAllValues.asScala + val argsR = argCaptorR.getAllValues.asScala + val argsS = argCaptorS.getAllValues.asScala + zipN(argsA, argsB, argsC, argsD, argsE, argsF, argsG, argsH, argsI, argsJ, argsK, argsL, argsM, argsN, argsO, argsP, argsQ, argsR, argsS) + } + + /** Capture one invocation of a mocked 19-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag, N: ClassTag, O: ClassTag, P: ClassTag, Q: ClassTag, R: ClassTag, S: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => _): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) = + capturingAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 20 iterables together into a Seq of 20-tuples. */ + private[this] def zipN[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C], arg3: Iterable[D], arg4: Iterable[E], arg5: Iterable[F], arg6: Iterable[G], arg7: Iterable[H], arg8: Iterable[I], arg9: Iterable[J], arg10: Iterable[K], arg11: Iterable[L], arg12: Iterable[M], arg13: Iterable[N], arg14: Iterable[O], arg15: Iterable[P], arg16: Iterable[Q], arg17: Iterable[R], arg18: Iterable[S], arg19: Iterable[T]): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] = { + arg0 + .zip(arg1) + .zip(arg2) + .zip(arg3) + .zip(arg4) + .zip(arg5) + .zip(arg6) + .zip(arg7) + .zip(arg8) + .zip(arg9) + .zip(arg10) + .zip(arg11) + .zip(arg12) + .zip(arg13) + .zip(arg14) + .zip(arg15) + .zip(arg16) + .zip(arg17) + .zip(arg18) + .zip(arg19) + .map({ case (((((((((((((((((((a, b), c), d), e), f), g), h), i), j), k), l), m), n), o), p), q), r), s), t) => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) }) + .toSeq + } + + /** Capture all invocations of a mocked 20-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag, N: ClassTag, O: ClassTag, P: ClassTag, Q: ClassTag, R: ClassTag, S: ClassTag, T: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => _): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + val argCaptorD = ArgumentCaptor.forClass(classTag[D].runtimeClass.asInstanceOf[Class[D]]) + val argCaptorE = ArgumentCaptor.forClass(classTag[E].runtimeClass.asInstanceOf[Class[E]]) + val argCaptorF = ArgumentCaptor.forClass(classTag[F].runtimeClass.asInstanceOf[Class[F]]) + val argCaptorG = ArgumentCaptor.forClass(classTag[G].runtimeClass.asInstanceOf[Class[G]]) + val argCaptorH = ArgumentCaptor.forClass(classTag[H].runtimeClass.asInstanceOf[Class[H]]) + val argCaptorI = ArgumentCaptor.forClass(classTag[I].runtimeClass.asInstanceOf[Class[I]]) + val argCaptorJ = ArgumentCaptor.forClass(classTag[J].runtimeClass.asInstanceOf[Class[J]]) + val argCaptorK = ArgumentCaptor.forClass(classTag[K].runtimeClass.asInstanceOf[Class[K]]) + val argCaptorL = ArgumentCaptor.forClass(classTag[L].runtimeClass.asInstanceOf[Class[L]]) + val argCaptorM = ArgumentCaptor.forClass(classTag[M].runtimeClass.asInstanceOf[Class[M]]) + val argCaptorN = ArgumentCaptor.forClass(classTag[N].runtimeClass.asInstanceOf[Class[N]]) + val argCaptorO = ArgumentCaptor.forClass(classTag[O].runtimeClass.asInstanceOf[Class[O]]) + val argCaptorP = ArgumentCaptor.forClass(classTag[P].runtimeClass.asInstanceOf[Class[P]]) + val argCaptorQ = ArgumentCaptor.forClass(classTag[Q].runtimeClass.asInstanceOf[Class[Q]]) + val argCaptorR = ArgumentCaptor.forClass(classTag[R].runtimeClass.asInstanceOf[Class[R]]) + val argCaptorS = ArgumentCaptor.forClass(classTag[S].runtimeClass.asInstanceOf[Class[S]]) + val argCaptorT = ArgumentCaptor.forClass(classTag[T].runtimeClass.asInstanceOf[Class[T]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture(), argCaptorD.capture(), argCaptorE.capture(), argCaptorF.capture(), argCaptorG.capture(), argCaptorH.capture(), argCaptorI.capture(), argCaptorJ.capture(), argCaptorK.capture(), argCaptorL.capture(), argCaptorM.capture(), argCaptorN.capture(), argCaptorO.capture(), argCaptorP.capture(), argCaptorQ.capture(), argCaptorR.capture(), argCaptorS.capture(), argCaptorT.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + val argsD = argCaptorD.getAllValues.asScala + val argsE = argCaptorE.getAllValues.asScala + val argsF = argCaptorF.getAllValues.asScala + val argsG = argCaptorG.getAllValues.asScala + val argsH = argCaptorH.getAllValues.asScala + val argsI = argCaptorI.getAllValues.asScala + val argsJ = argCaptorJ.getAllValues.asScala + val argsK = argCaptorK.getAllValues.asScala + val argsL = argCaptorL.getAllValues.asScala + val argsM = argCaptorM.getAllValues.asScala + val argsN = argCaptorN.getAllValues.asScala + val argsO = argCaptorO.getAllValues.asScala + val argsP = argCaptorP.getAllValues.asScala + val argsQ = argCaptorQ.getAllValues.asScala + val argsR = argCaptorR.getAllValues.asScala + val argsS = argCaptorS.getAllValues.asScala + val argsT = argCaptorT.getAllValues.asScala + zipN(argsA, argsB, argsC, argsD, argsE, argsF, argsG, argsH, argsI, argsJ, argsK, argsL, argsM, argsN, argsO, argsP, argsQ, argsR, argsS, argsT) + } + + /** Capture one invocation of a mocked 20-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag, N: ClassTag, O: ClassTag, P: ClassTag, Q: ClassTag, R: ClassTag, S: ClassTag, T: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => _): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) = + capturingAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 21 iterables together into a Seq of 21-tuples. */ + private[this] def zipN[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C], arg3: Iterable[D], arg4: Iterable[E], arg5: Iterable[F], arg6: Iterable[G], arg7: Iterable[H], arg8: Iterable[I], arg9: Iterable[J], arg10: Iterable[K], arg11: Iterable[L], arg12: Iterable[M], arg13: Iterable[N], arg14: Iterable[O], arg15: Iterable[P], arg16: Iterable[Q], arg17: Iterable[R], arg18: Iterable[S], arg19: Iterable[T], arg20: Iterable[U]): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] = { + arg0 + .zip(arg1) + .zip(arg2) + .zip(arg3) + .zip(arg4) + .zip(arg5) + .zip(arg6) + .zip(arg7) + .zip(arg8) + .zip(arg9) + .zip(arg10) + .zip(arg11) + .zip(arg12) + .zip(arg13) + .zip(arg14) + .zip(arg15) + .zip(arg16) + .zip(arg17) + .zip(arg18) + .zip(arg19) + .zip(arg20) + .map({ case ((((((((((((((((((((a, b), c), d), e), f), g), h), i), j), k), l), m), n), o), p), q), r), s), t), u) => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) }) + .toSeq + } + + /** Capture all invocations of a mocked 21-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag, N: ClassTag, O: ClassTag, P: ClassTag, Q: ClassTag, R: ClassTag, S: ClassTag, T: ClassTag, U: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => _): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + val argCaptorD = ArgumentCaptor.forClass(classTag[D].runtimeClass.asInstanceOf[Class[D]]) + val argCaptorE = ArgumentCaptor.forClass(classTag[E].runtimeClass.asInstanceOf[Class[E]]) + val argCaptorF = ArgumentCaptor.forClass(classTag[F].runtimeClass.asInstanceOf[Class[F]]) + val argCaptorG = ArgumentCaptor.forClass(classTag[G].runtimeClass.asInstanceOf[Class[G]]) + val argCaptorH = ArgumentCaptor.forClass(classTag[H].runtimeClass.asInstanceOf[Class[H]]) + val argCaptorI = ArgumentCaptor.forClass(classTag[I].runtimeClass.asInstanceOf[Class[I]]) + val argCaptorJ = ArgumentCaptor.forClass(classTag[J].runtimeClass.asInstanceOf[Class[J]]) + val argCaptorK = ArgumentCaptor.forClass(classTag[K].runtimeClass.asInstanceOf[Class[K]]) + val argCaptorL = ArgumentCaptor.forClass(classTag[L].runtimeClass.asInstanceOf[Class[L]]) + val argCaptorM = ArgumentCaptor.forClass(classTag[M].runtimeClass.asInstanceOf[Class[M]]) + val argCaptorN = ArgumentCaptor.forClass(classTag[N].runtimeClass.asInstanceOf[Class[N]]) + val argCaptorO = ArgumentCaptor.forClass(classTag[O].runtimeClass.asInstanceOf[Class[O]]) + val argCaptorP = ArgumentCaptor.forClass(classTag[P].runtimeClass.asInstanceOf[Class[P]]) + val argCaptorQ = ArgumentCaptor.forClass(classTag[Q].runtimeClass.asInstanceOf[Class[Q]]) + val argCaptorR = ArgumentCaptor.forClass(classTag[R].runtimeClass.asInstanceOf[Class[R]]) + val argCaptorS = ArgumentCaptor.forClass(classTag[S].runtimeClass.asInstanceOf[Class[S]]) + val argCaptorT = ArgumentCaptor.forClass(classTag[T].runtimeClass.asInstanceOf[Class[T]]) + val argCaptorU = ArgumentCaptor.forClass(classTag[U].runtimeClass.asInstanceOf[Class[U]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture(), argCaptorD.capture(), argCaptorE.capture(), argCaptorF.capture(), argCaptorG.capture(), argCaptorH.capture(), argCaptorI.capture(), argCaptorJ.capture(), argCaptorK.capture(), argCaptorL.capture(), argCaptorM.capture(), argCaptorN.capture(), argCaptorO.capture(), argCaptorP.capture(), argCaptorQ.capture(), argCaptorR.capture(), argCaptorS.capture(), argCaptorT.capture(), argCaptorU.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + val argsD = argCaptorD.getAllValues.asScala + val argsE = argCaptorE.getAllValues.asScala + val argsF = argCaptorF.getAllValues.asScala + val argsG = argCaptorG.getAllValues.asScala + val argsH = argCaptorH.getAllValues.asScala + val argsI = argCaptorI.getAllValues.asScala + val argsJ = argCaptorJ.getAllValues.asScala + val argsK = argCaptorK.getAllValues.asScala + val argsL = argCaptorL.getAllValues.asScala + val argsM = argCaptorM.getAllValues.asScala + val argsN = argCaptorN.getAllValues.asScala + val argsO = argCaptorO.getAllValues.asScala + val argsP = argCaptorP.getAllValues.asScala + val argsQ = argCaptorQ.getAllValues.asScala + val argsR = argCaptorR.getAllValues.asScala + val argsS = argCaptorS.getAllValues.asScala + val argsT = argCaptorT.getAllValues.asScala + val argsU = argCaptorU.getAllValues.asScala + zipN(argsA, argsB, argsC, argsD, argsE, argsF, argsG, argsH, argsI, argsJ, argsK, argsL, argsM, argsN, argsO, argsP, argsQ, argsR, argsS, argsT, argsU) + } + + /** Capture one invocation of a mocked 21-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag, N: ClassTag, O: ClassTag, P: ClassTag, Q: ClassTag, R: ClassTag, S: ClassTag, T: ClassTag, U: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => _): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) = + capturingAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](func).lastOption.getOrElse(noArgWasCaptured()) + + /** Zip 22 iterables together into a Seq of 22-tuples. */ + private[this] def zipN[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](arg0: Iterable[A], arg1: Iterable[B], arg2: Iterable[C], arg3: Iterable[D], arg4: Iterable[E], arg5: Iterable[F], arg6: Iterable[G], arg7: Iterable[H], arg8: Iterable[I], arg9: Iterable[J], arg10: Iterable[K], arg11: Iterable[L], arg12: Iterable[M], arg13: Iterable[N], arg14: Iterable[O], arg15: Iterable[P], arg16: Iterable[Q], arg17: Iterable[R], arg18: Iterable[S], arg19: Iterable[T], arg20: Iterable[U], arg21: Iterable[V]): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] = { + arg0 + .zip(arg1) + .zip(arg2) + .zip(arg3) + .zip(arg4) + .zip(arg5) + .zip(arg6) + .zip(arg7) + .zip(arg8) + .zip(arg9) + .zip(arg10) + .zip(arg11) + .zip(arg12) + .zip(arg13) + .zip(arg14) + .zip(arg15) + .zip(arg16) + .zip(arg17) + .zip(arg18) + .zip(arg19) + .zip(arg20) + .zip(arg21) + .map({ case (((((((((((((((((((((a, b), c), d), e), f), g), h), i), j), k), l), m), n), o), p), q), r), s), t), u), v) => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) }) + .toSeq + } + + /** Capture all invocations of a mocked 22-ary method */ + def capturingAll[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag, N: ClassTag, O: ClassTag, P: ClassTag, Q: ClassTag, R: ClassTag, S: ClassTag, T: ClassTag, U: ClassTag, V: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => _): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] = { + val argCaptorA = ArgumentCaptor.forClass(classTag[A].runtimeClass.asInstanceOf[Class[A]]) + val argCaptorB = ArgumentCaptor.forClass(classTag[B].runtimeClass.asInstanceOf[Class[B]]) + val argCaptorC = ArgumentCaptor.forClass(classTag[C].runtimeClass.asInstanceOf[Class[C]]) + val argCaptorD = ArgumentCaptor.forClass(classTag[D].runtimeClass.asInstanceOf[Class[D]]) + val argCaptorE = ArgumentCaptor.forClass(classTag[E].runtimeClass.asInstanceOf[Class[E]]) + val argCaptorF = ArgumentCaptor.forClass(classTag[F].runtimeClass.asInstanceOf[Class[F]]) + val argCaptorG = ArgumentCaptor.forClass(classTag[G].runtimeClass.asInstanceOf[Class[G]]) + val argCaptorH = ArgumentCaptor.forClass(classTag[H].runtimeClass.asInstanceOf[Class[H]]) + val argCaptorI = ArgumentCaptor.forClass(classTag[I].runtimeClass.asInstanceOf[Class[I]]) + val argCaptorJ = ArgumentCaptor.forClass(classTag[J].runtimeClass.asInstanceOf[Class[J]]) + val argCaptorK = ArgumentCaptor.forClass(classTag[K].runtimeClass.asInstanceOf[Class[K]]) + val argCaptorL = ArgumentCaptor.forClass(classTag[L].runtimeClass.asInstanceOf[Class[L]]) + val argCaptorM = ArgumentCaptor.forClass(classTag[M].runtimeClass.asInstanceOf[Class[M]]) + val argCaptorN = ArgumentCaptor.forClass(classTag[N].runtimeClass.asInstanceOf[Class[N]]) + val argCaptorO = ArgumentCaptor.forClass(classTag[O].runtimeClass.asInstanceOf[Class[O]]) + val argCaptorP = ArgumentCaptor.forClass(classTag[P].runtimeClass.asInstanceOf[Class[P]]) + val argCaptorQ = ArgumentCaptor.forClass(classTag[Q].runtimeClass.asInstanceOf[Class[Q]]) + val argCaptorR = ArgumentCaptor.forClass(classTag[R].runtimeClass.asInstanceOf[Class[R]]) + val argCaptorS = ArgumentCaptor.forClass(classTag[S].runtimeClass.asInstanceOf[Class[S]]) + val argCaptorT = ArgumentCaptor.forClass(classTag[T].runtimeClass.asInstanceOf[Class[T]]) + val argCaptorU = ArgumentCaptor.forClass(classTag[U].runtimeClass.asInstanceOf[Class[U]]) + val argCaptorV = ArgumentCaptor.forClass(classTag[V].runtimeClass.asInstanceOf[Class[V]]) + func(argCaptorA.capture(), argCaptorB.capture(), argCaptorC.capture(), argCaptorD.capture(), argCaptorE.capture(), argCaptorF.capture(), argCaptorG.capture(), argCaptorH.capture(), argCaptorI.capture(), argCaptorJ.capture(), argCaptorK.capture(), argCaptorL.capture(), argCaptorM.capture(), argCaptorN.capture(), argCaptorO.capture(), argCaptorP.capture(), argCaptorQ.capture(), argCaptorR.capture(), argCaptorS.capture(), argCaptorT.capture(), argCaptorU.capture(), argCaptorV.capture()) + val argsA = argCaptorA.getAllValues.asScala + val argsB = argCaptorB.getAllValues.asScala + val argsC = argCaptorC.getAllValues.asScala + val argsD = argCaptorD.getAllValues.asScala + val argsE = argCaptorE.getAllValues.asScala + val argsF = argCaptorF.getAllValues.asScala + val argsG = argCaptorG.getAllValues.asScala + val argsH = argCaptorH.getAllValues.asScala + val argsI = argCaptorI.getAllValues.asScala + val argsJ = argCaptorJ.getAllValues.asScala + val argsK = argCaptorK.getAllValues.asScala + val argsL = argCaptorL.getAllValues.asScala + val argsM = argCaptorM.getAllValues.asScala + val argsN = argCaptorN.getAllValues.asScala + val argsO = argCaptorO.getAllValues.asScala + val argsP = argCaptorP.getAllValues.asScala + val argsQ = argCaptorQ.getAllValues.asScala + val argsR = argCaptorR.getAllValues.asScala + val argsS = argCaptorS.getAllValues.asScala + val argsT = argCaptorT.getAllValues.asScala + val argsU = argCaptorU.getAllValues.asScala + val argsV = argCaptorV.getAllValues.asScala + zipN(argsA, argsB, argsC, argsD, argsE, argsF, argsG, argsH, argsI, argsJ, argsK, argsL, argsM, argsN, argsO, argsP, argsQ, argsR, argsS, argsT, argsU, argsV) + } + + /** Capture one invocation of a mocked 22-ary method */ + def capturingOne[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag, H: ClassTag, I: ClassTag, J: ClassTag, K: ClassTag, L: ClassTag, M: ClassTag, N: ClassTag, O: ClassTag, P: ClassTag, Q: ClassTag, R: ClassTag, S: ClassTag, T: ClassTag, U: ClassTag, V: ClassTag](func: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => _): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) = + capturingAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](func).lastOption.getOrElse(noArgWasCaptured()) + +} + diff --git a/util-test/src/test/scala/com/twitter/util/testing/ArgumentCaptureTest.scala b/util-test/src/test/scala/com/twitter/util/testing/ArgumentCaptureTest.scala new file mode 100644 index 0000000000..a651dbb4f7 --- /dev/null +++ b/util-test/src/test/scala/com/twitter/util/testing/ArgumentCaptureTest.scala @@ -0,0 +1,131 @@ +package com.twitter.util.testing + +import org.junit.runner.RunWith +import org.mockito.Matchers._ +import org.mockito.Mockito._ +import org.scalatest.FunSuite +import org.scalatest.junit.JUnitRunner +import org.scalatest.mock.MockitoSugar + +@RunWith(classOf[JUnitRunner]) +class ArgumentCaptureTest extends FunSuite with MockitoSugar with ArgumentCapture { + class MockSubject { + def method1(arg: String): Long = 0L + def method2(arg1: String, arg2: String): Long = 0L + def method3(arg1: String, arg2: String, arg3: String): Long = 0L + def method4(arg1: String, arg2: String, arg3: String, arg4: String): Long = 0L + def method5(arg1: String, arg2: String, arg3: String, arg4: String, arg5: String): Long = 0L + } + + test("captureOne should handle 1-ary functions") { + val theMockSubject = mock[MockSubject] + when(theMockSubject.method1(any[String])).thenReturn(123L) + + assert(theMockSubject.method1("foo") === 123L) + + val captured = capturingOne(verify(theMockSubject).method1 _) + assert(captured === "foo") + } + + test("captureOne should handle 2-ary functions") { + val theMockSubject = mock[MockSubject] + when(theMockSubject.method2(any[String], any[String])).thenReturn(456L) + + assert(theMockSubject.method2("foo", "bar") === 456L) + + val captured = capturingOne(verify(theMockSubject).method2 _) + assert(captured === ("foo", "bar")) + } + + test("captureOne should handle 3-ary functions") { + val theMockSubject = mock[MockSubject] + when(theMockSubject.method3(any[String], any[String], any[String])).thenReturn(136L) + + assert(theMockSubject.method3("foo", "bar", "baz") === 136L) + + val captured = capturingOne(verify(theMockSubject).method3 _) + assert(captured === ("foo", "bar", "baz")) + } + + test("captureOne should handle 4-ary functions") { + val theMockSubject = mock[MockSubject] + when(theMockSubject.method4(any[String], any[String], any[String], any[String])).thenReturn(149L) + + assert(theMockSubject.method4("north", "east", "south", "west") === 149L) + + val captured = capturingOne(verify(theMockSubject).method4 _) + assert(captured === ("north", "east", "south", "west")) + } + + test("captureOne should handle 5-ary functions") { + val theMockSubject = mock[MockSubject] + when(theMockSubject.method5(any[String], any[String], any[String], any[String], any[String])).thenReturn(789L) + + assert(theMockSubject.method5("doh", "ray", "mi", "fa", "so") === 789L) + + val captured = capturingOne(verify(theMockSubject).method5 _) + assert(captured === ("doh", "ray", "mi", "fa", "so")) + } + + test("captureAll should handle 1-ary functions") { + val theMockSubject = mock[MockSubject] + when(theMockSubject.method1(any[String])).thenReturn(123L) + assert(theMockSubject.method1("foo") === 123L) + assert(theMockSubject.method1("bar") === 123L) + + val captured = capturingAll(verify(theMockSubject, times(2)).method1 _) + assert(captured === Seq("foo", "bar")) + } + + test("captureAll should handle 2-ary functions") { + val theMockSubject = mock[MockSubject] + when(theMockSubject.method2(any[String], any[String])).thenReturn(456L) + assert(theMockSubject.method2("foo", "bar") === 456L) + assert(theMockSubject.method2("baz", "spam") === 456L) + + val captured = capturingAll(verify(theMockSubject, times(2)).method2 _) + assert(captured === Seq(("foo", "bar"), ("baz", "spam"))) + } + + test("captureAll should handle 3-ary functions") { + val theMockSubject = mock[MockSubject] + when(theMockSubject.method3(any[String], any[String], any[String])).thenReturn(136L) + + assert(theMockSubject.method3("foo", "bar", "baz") === 136L) + assert(theMockSubject.method3("spam", "ham", "eggs") === 136L) + + val captured = capturingAll(verify(theMockSubject, times(2)).method3 _) + assert(captured === Seq( + ("foo", "bar", "baz"), + ("spam", "ham", "eggs") + )) + } + + test("captureAll should handle 4-ary functions") { + // This is really just a test of zip4 + val theMockSubject = mock[MockSubject] + when(theMockSubject.method4(any[String], any[String], any[String], any[String])).thenReturn(149L) + assert(theMockSubject.method4("foo", "bar", "baz", "spam") === 149L) + assert(theMockSubject.method4("north", "east", "south", "west") === 149L) + + val captured = capturingAll(verify(theMockSubject, times(2)).method4 _) + assert(captured === Seq( + ("foo", "bar", "baz", "spam"), + ("north", "east", "south", "west") + )) + } + + test("captureAll should handle 5-ary functions") { + // This is really just a test of zip5 + val theMockSubject = mock[MockSubject] + when(theMockSubject.method5(any[String], any[String], any[String], any[String], any[String])).thenReturn(789L) + assert(theMockSubject.method5("foo", "bar", "baz", "spam", "ham") === 789L) + assert(theMockSubject.method5("doh", "ray", "mi", "fa", "so") === 789L) + + val captured = capturingAll(verify(theMockSubject, times(2)).method5 _) + assert(captured === Seq( + ("foo", "bar", "baz", "spam", "ham"), + ("doh", "ray", "mi", "fa", "so") + )) + } +}