MockitoFixture

final def !=(arg0: Any): Boolean

def !==[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

def !==(right: Null): TripleEqualsInvocation[Null]

def !==[T](right: T): TripleEqualsInvocation[T]

final def ##(): Int

final def ==(arg0: Any): Boolean

def ===[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

def ===(right: Null): TripleEqualsInvocation[Null]

def ===[T](right: T): TripleEqualsInvocation[T]

def any[T]: T

Delegates to ArgumentMatchers.any(), it's main purpose is to remove the () out of the method call, if you try to do that directly on the test you get this error

def anyBoolean: Boolean

Delegates to ArgumentMatchers.anyBoolean(), it's only here so we expose all the ArgumentMatchers on a single place as any[T] would do the job just fine

def anyByte: Byte

Delegates to ArgumentMatchers.anyByte(), it's only here so we expose all the ArgumentMatchers on a single place as any[T] would do the job just fine

def anyChar: Char

Delegates to ArgumentMatchers.anyChar(), it's only here so we expose all the ArgumentMatchers on a single place as any[T] would do the job just fine

def anyDouble: Double

Delegates to ArgumentMatchers.anyDouble(), it's only here so we expose all the ArgumentMatchers on a single place as any[T] would do the job just fine

def anyFloat: Float

Delegates to ArgumentMatchers.anyFloat(), it's only here so we expose all the ArgumentMatchers on a single place as any[T] would do the job just fine

def anyInt: Int

Delegates to ArgumentMatchers.anyInt(), it's only here so we expose all the ArgumentMatchers on a single place as any[T] would do the job just fine

def anyIterable[T]: Iterable[T]

Iterable matcher that use Scala Iterable to avoid compile errors like Error:(40, 60) type mismatch; found : Iterable[String] (in java.util) required: Iterable[?] (in scala.collection.immutable)

def anyList[T]: List[T]

List matcher that use Scala List to avoid compile errors like Error:(40, 60) type mismatch; found : List[String] (in java.util) required: List[?] (in scala.collection.immutable)

def anyLong: Long

Delegates to ArgumentMatchers.anyLong(), it's only here so we expose all the ArgumentMatchers on a single place as any[T] would do the job just fine

def anyMap[K, V]: Map[K, V]

Map matcher that use Scala Map to avoid compile errors like Error:(40, 60) type mismatch; found : Map[String, String] (in java.util) required: Map[?] (in scala.collection.immutable)

def anySeq[T]: Seq[T]

Seq matcher that use Scala Seq to avoid compile errors like Error:(40, 60) type mismatch; found : List[String] (in java.util) required: Seq[?] (in scala.collection.immutable)

def anySet[T]: Set[T]

Set matcher that use Scala Set to avoid compile errors like Error:(40, 60) type mismatch; found : Set[String] (in java.util) required: Set[?] (in scala.collection.immutable)

def anyShort: Short

Delegates to ArgumentMatchers.anyShort(), it's only here so we expose all the ArgumentMatchers on a single place as any[T] would do the job just fine

def anyVal[T](implicit valueClassMatchers: ValueClassMatchers[T]): T

Wraps the standard 'any' matcher on the value class provided, this one requires the type to be explicit

def argThat[T](matcher: ArgumentMatcher[T]): T

Delegates to ArgumentMatchers.argThat(matcher), it's only here so we expose all the ArgumentMatchers on a single place

def argumentCaptor[T](implicit arg0: ClassTag[T]): ArgumentCaptor[T]

Delegates to ArgumentCaptor.forClass(type: Class[T]) It provides a nicer API as you can, for instance, do argumentCaptor[SomeClass] instead of ArgumentCaptor.forClass(classOf[SomeClass])

final def asInstanceOf[T0]: T0

macro def assert(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

macro def assert(condition: Boolean)(implicit prettifier: Prettifier, pos: Position): Assertion

macro def assertCompiles(code: String)(implicit pos: Position): Assertion

macro def assertDoesNotCompile(code: String)(implicit pos: Position): Assertion

def assertResult(expected: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

def assertResult(expected: Any, clue: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

def assertThrows[T <: AnyRef](f: ⇒ Any)(implicit classTag: ClassTag[T], pos: Position): Assertion

macro def assertTypeError(code: String)(implicit pos: Position): Assertion

val assertionsHelper: AssertionsHelper

macro def assume(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

macro def assume(condition: Boolean)(implicit prettifier: Prettifier, pos: Position): Assertion

def atLeast(minNumberOfInvocations: Int): VerificationMode

Delegates to Mockito.atLeast(), it's only here to expose the full Mockito API

def atLeastOnce: VerificationMode

Delegates to Mockito.atLeastOnce(), it removes the parenthesis to have a cleaner API

def atMost(maxNumberOfInvocations: Int): VerificationMode

Delegates to Mockito.atMost(), it's only here to expose the full Mockito API

def booleanThat(matcher: ArgumentMatcher[Boolean]): Boolean

Delegates the call to argThat but using the Scala "primitive", this provides avoids an unnecessary implicit conversion that would be necessary if we used the Java version

def byteThat(matcher: ArgumentMatcher[Byte]): Byte

Delegates the call to argThat but using the Scala "primitives", this provides avoids an unnecessary implicit conversion that would be necessary if we used the Java version

def calls(wantedNumberOfInvocations: Int): VerificationMode

Delegates to Mockito.calls(), it's only here to expose the full Mockito API

def cancel(cause: Throwable)(implicit pos: Position): Nothing

def cancel(message: String, cause: Throwable)(implicit pos: Position): Nothing

def cancel(message: String)(implicit pos: Position): Nothing

def cancel()(implicit pos: Position): Nothing

def charThat(matcher: ArgumentMatcher[Char]): Char

Delegates the call to argThat but using the Scala "primitive", this provides avoids an unnecessary implicit conversion that would be necessary if we used the Java version

def clone(): AnyRef

def contains(substring: String): String

Delegates to ArgumentMatchers.contains(), it's only here so we expose all the ArgumentMatchers on a single place

def conversionCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], cnv: (B) ⇒ A): CanEqual[A, B]

def convertEquivalenceToAToBConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: <:<[A, B]): CanEqual[A, B]

def convertEquivalenceToAToBConversionConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: (A) ⇒ B): CanEqual[A, B]

def convertEquivalenceToBToAConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: <:<[B, A]): CanEqual[A, B]

def convertEquivalenceToBToAConversionConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: (B) ⇒ A): CanEqual[A, B]

def convertToCheckingEqualizer[T](left: T): CheckingEqualizer[T]

implicit def convertToEqualizer[T](left: T): Equalizer[T]

def defaultEquality[A]: Equality[A]

def doAnswer[T](f: (InvocationOnMock) ⇒ T): Stubber

Delegates to Mockito.doAnswer(), it's only here to expose the full Mockito API

def doCallRealMethod: Stubber

Delegates to Mockito.doCallRealMethod(), it removes the parenthesis to have a cleaner API

def doNothing: Stubber

Delegates to Mockito.doNothing(), it removes the parenthesis to have a cleaner API

def doReturn[T](toBeReturned: T, toBeReturnedNext: T*): Stubber

Delegates the call to Mockito.doReturn(toBeReturned, toBeReturnedNext) but fixes the following compiler issue that happens because the overloaded vararg on the Java side

Error:(33, 25) ambiguous reference to overloaded definition,
both method doReturn in class Mockito of type (x$1: Any, x$2: Object*)org.mockito.stubbing.Stubber
and  method doReturn in class Mockito of type (x$1: Any)org.mockito.stubbing.Stubber
match argument types (`Type`)

def doThrow[T <: Throwable](implicit arg0: ClassTag[T]): Stubber

Delegates to Mockito.doThrow(type: Class[T]) It provides a nicer API as you can, for instance, do doThrow[Throwable] instead of doThrow(classOf[Throwable])

def doThrow(toBeThrown: Throwable*): Stubber

Delegates to Mockito.doThrow, it's only here so we expose all the Mockito API on a single place

def doubleThat(matcher: ArgumentMatcher[Double]): Double

Delegates the call to argThat but using the Scala "primitive", this provides avoids an unnecessary implicit conversion that would be necessary if we used the Java version

def endsWith(suffix: String): String

Delegates to ArgumentMatchers.endsWith(), it's only here so we expose all the ArgumentMatchers on a single place

final def eq(arg0: AnyRef): Boolean

def eqTo[T](value: T): T

Delegates to ArgumentMatchers.eq(), it renames the method to eqTo to avoid clashes with the Scala eq method used for reference equality

def eqToVal[T](value: Any)(implicit valueClassMatchers: ValueClassMatchers[T]): T

Wraps the standard 'ArgumentMatchers.eq()' matcher on the value class provided, this one requires the type to be explicit

def equals(arg0: Any): Boolean

final def execute(testName: String, configMap: ConfigMap, color: Boolean, durations: Boolean, shortstacks: Boolean, fullstacks: Boolean, stats: Boolean): Unit

def expectedTestCount(filter: Filter): Int

def fail(cause: Throwable)(implicit pos: Position): Nothing

def fail(message: String, cause: Throwable)(implicit pos: Position): Nothing

def fail(message: String)(implicit pos: Position): Nothing

def fail()(implicit pos: Position): Nothing

def finalize(): Unit

def floatThat(matcher: ArgumentMatcher[Float]): Float

Delegates the call to argThat but using the Scala "primitive", this provides avoids an unnecessary implicit conversion that would be necessary if we used the Java version

def function0[T](value: T): () ⇒ T

final def getClass(): Class[_]

def hashCode(): Int

def ignoreStubs(mocks: AnyRef*): Array[AnyRef]

Delegates to Mockito.ignoreStubs(), it's only here to expose the full Mockito API

def inOrder(mocks: AnyRef*): InOrder

Delegates to Mockito.inOrder(), it's only here to expose the full Mockito API

def intThat(matcher: ArgumentMatcher[Int]): Int

Delegates the call to argThat but using the Scala "primitive", this provides avoids an unnecessary implicit conversion that would be necessary if we used the Java version

def intercept[T <: AnyRef](f: ⇒ Any)(implicit classTag: ClassTag[T], pos: Position): T

def isA[T](implicit classTag: ClassTag[T]): T

Delegates to ArgumentMatchers.isA(type: Class[T]) It provides a nicer API as you can, for instance, do isA[String] instead of isA(classOf[String])

final def isInstanceOf[T0]: Boolean

def longThat(matcher: ArgumentMatcher[Long]): Long

Delegates the call to argThat but using the Scala "primitive", this provides avoids an unnecessary conversion that would be necessary used the Java version

def lowPriorityConversionCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], cnv: (A) ⇒ B): CanEqual[A, B]

def lowPriorityTypeCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], ev: <:<[A, B]): CanEqual[A, B]

def matches(regex: String): String

Delegates to ArgumentMatchers.matches(), it's only here so we expose all the ArgumentMatchers on a single place

def mock[T <: AnyRef](name: String)(implicit arg0: ClassTag[T], arg1: scala.reflect.api.JavaUniverse.TypeTag[T], defaultAnswer: DefaultAnswer): T

Delegates to Mockito.mock(type: Class[T], name: String) It provides a nicer API as you can, for instance, do mock[MyClass](name) instead of mock(classOf[MyClass], name)

def mock[T <: AnyRef](mockSettings: MockSettings)(implicit arg0: ClassTag[T], arg1: scala.reflect.api.JavaUniverse.TypeTag[T]): T

Delegates to Mockito.mock(type: Class[T], mockSettings: MockSettings) It provides a nicer API as you can, for instance, do mock[MyClass](mockSettings) instead of mock(classOf[MyClass], mockSettings)

def mock[T <: AnyRef](defaultAnswer: DefaultAnswer)(implicit arg0: ClassTag[T], arg1: scala.reflect.api.JavaUniverse.TypeTag[T]): T

Delegates to Mockito.mock(type: Class[T], defaultAnswer: Answer[_]) It provides a nicer API as you can, for instance, do mock[MyClass](defaultAnswer) instead of mock(classOf[MyClass], defaultAnswer)

def mock[T <: AnyRef](implicit arg0: ClassTag[T], arg1: scala.reflect.api.JavaUniverse.TypeTag[T], defaultAnswer: DefaultAnswer): T

Delegates to Mockito.mock(type: Class[T]) It provides a nicer API as you can, for instance, do mock[MyClass] instead of mock(classOf[MyClass])

def mock[T <: AnyRef](defaultAnswer: Answer[_])(implicit arg0: ClassTag[T], arg1: scala.reflect.api.JavaUniverse.TypeTag[T]): T

def mockingDetails(toInspect: AnyRef): MockingDetails

Delegates to Mockito.mockingDetails(), it's only here to expose the full Mockito API

final def ne(arg0: AnyRef): Boolean

def nestedSuites: IndexedSeq[Suite]

def never: VerificationMode

Delegates to Mockito.never(), it removes the parenthesis to have a cleaner API

final def notify(): Unit

final def notifyAll(): Unit

def only: VerificationMode

Delegates to Mockito.only(), it removes the parenthesis to have a cleaner API

def pending: Assertion with PendingStatement

def pendingUntilFixed(f: ⇒ Unit)(implicit pos: Position): Assertion with PendingStatement

def refEq[T](value: T, excludeFields: String*): T

Delegates to ArgumentMatchers.refEq(), it's only here so we expose all the ArgumentMatchers on a single place

def rerunner: Option[String]

def reset(mocks: AnyRef*): Unit

Delegates to Mockito.reset(T... mocks), but restores the default stubs that deal with default argument values

def run(testName: Option[String], args: Args): Status

def runNestedSuites(args: Args): Status

def runTest(testName: String, args: Args): Status

def runTests(testName: Option[String], args: Args): Status

def same[T](value: T): T

Delegates to ArgumentMatchers.same(), it's only here so we expose all the ArgumentMatchers on a single place

def shortThat(matcher: ArgumentMatcher[Short]): Short

Delegates the call to argThat but using the Scala "primitive", this provides avoids an unnecessary implicit conversion that would be necessary if we used the Java version

def spy[T](realObj: T): T

Delegates to Mockito.spy(), it's only here to expose the full Mockito API

def spyLambda[T <: AnyRef](realObj: T)(implicit arg0: ClassTag[T]): T

Creates a "spy" in a way that supports lambdas and anonymous classes as they don't work with the standard spy as they are created as final classes by the compiler

def startsWith(prefix: String): String

Delegates to ArgumentMatchers.startsWith(), it's only here so we expose all the ArgumentMatchers on a single place

val styleName: String

final val succeed: Assertion

def suiteId: String

def suiteName: String

final def synchronized[T0](arg0: ⇒ T0): T0

def tags: Map[String, Set[String]]

def testDataFor(testName: String, theConfigMap: ConfigMap): TestData

def testNames: Set[String]

def timeout(millis: Int): VerificationWithTimeout

Delegates to Mockito.timeout(), it's only here to expose the full Mockito API

def times(wantedNumberOfInvocations: Int): VerificationMode

Delegates to Mockito.times(), it's only here to expose the full Mockito API

def toString(): String

def typeCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], ev: <:<[B, A]): CanEqual[A, B]

implicit def unconstrainedEquality[A, B](implicit equalityOfA: Equality[A]): CanEqual[A, B]

def validateMockitoUsage(): Unit

Delegates to Mockito.validateMockitoUsage(), it's only here to expose the full Mockito API

def verify[T](mock: T, mode: VerificationMode): T

Delegates to Mockito.verify(), it's only here to expose the full Mockito API

def verify[T](mock: T): T

Delegates to Mockito.verify(), it's only here to expose the full Mockito API

def verifyNoMoreInteractions(mocks: AnyRef*): Unit

Delegates to Mockito.verifyNoMoreInteractions(Object... mocks), but ignores the default stubs that deal with default argument values

def verifyZeroInteractions(mocks: AnyRef*): Unit

Delegates to Mockito.verifyZeroInteractions(), it's only here to expose the full Mockito API

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def when[T](methodCall: T): OngoingStubbing[T]

Delegates to Mockito.when(), it's only here to expose the full Mockito API

def withClue[T](clue: Any)(fun: ⇒ T): T

def withFixture(test: NoArgTest): Outcome

def withSettings(implicit defaultAnswer: DefaultAnswer): MockSettings

Delegates to Mockito.withSettings(), it's only here to expose the full Mockito API

final def execute: Unit

def isNotNull[T]: T

Delegates to ArgumentMatchers.isNotNull(), it's only here so we expose all the ArgumentMatchers on a single place, but marked as @deprecated as you shouldn't be testing for nulls on Scala

def isNull[T]: T

Delegates to ArgumentMatchers.isNull(), it's only here so we expose all the ArgumentMatchers on a single place, but marked as @deprecated as you shouldn't be testing for nulls on Scala

def trap[T](f: ⇒ T): Throwable