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

def *[T](implicit arg0: AnyMatcher[T]): T

Alias for org.mockito.matchers.MacroBasedMatchers.any

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](implicit arg0: AnyMatcher[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

def anyByte: Byte

def anyChar: Char

def anyDouble: Double

def anyFloat: Float

def anyInt: Int

def anyIterable[T]: Iterable[T]

def anyList[T]: List[T]

def anyLong: Long

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

def anySeq[T]: Seq[T]

def anySet[T]: Set[T]

def anyShort: Short

def argMatching[T](pf: PartialFunction[Any, Unit]): T

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

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

def atLeastOnce: VerificationMode

def atMost(maxNumberOfInvocations: Int): VerificationMode

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

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

def calls(wantedNumberOfInvocations: Int): VerificationMode

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

def clone(): AnyRef

def contains(substring: String): String

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]

implicit def convertNumericToPlusOrMinusWrapper[T](pivot: T)(implicit arg0: Numeric[T]): PlusOrMinusWrapper[T]

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

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

def defaultEquality[A]: Equality[A]

def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) ⇒ R)(implicit arg0: ValueClassExtractor[R]): Stubber

def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) ⇒ R)(implicit arg0: ValueClassExtractor[R]): Stubber

def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8) ⇒ R)(implicit arg0: ValueClassExtractor[R]): Stubber

def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, R](f: (P0, P1, P2, P3, P4, P5, P6, P7) ⇒ R)(implicit arg0: ValueClassExtractor[R]): Stubber

def doAnswer[P0, P1, P2, P3, P4, P5, P6, R](f: (P0, P1, P2, P3, P4, P5, P6) ⇒ R)(implicit arg0: ValueClassExtractor[R]): Stubber

def doAnswer[P0, P1, P2, P3, P4, P5, R](f: (P0, P1, P2, P3, P4, P5) ⇒ R)(implicit arg0: ValueClassExtractor[R]): Stubber

def doAnswer[P0, P1, P2, P3, P4, R](f: (P0, P1, P2, P3, P4) ⇒ R)(implicit arg0: ValueClassExtractor[R]): Stubber

def doAnswer[P0, P1, P2, P3, R](f: (P0, P1, P2, P3) ⇒ R)(implicit arg0: ValueClassExtractor[R]): Stubber

def doAnswer[P0, P1, P2, R](f: (P0, P1, P2) ⇒ R)(implicit arg0: ValueClassExtractor[R]): Stubber

def doAnswer[P0, P1, R](f: (P0, P1) ⇒ R)(implicit arg0: ValueClassExtractor[R]): Stubber

def doAnswer[P0, R](f: (P0) ⇒ R)(implicit arg0: ClassTag[P0], arg1: ValueClassExtractor[R]): Stubber

def doAnswer[R](l: ⇒ R)(implicit arg0: ValueClassExtractor[R]): Stubber

def doCallRealMethod: Stubber

def doNothing: Stubber

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

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

def doThrow(toBeThrown: Throwable*): Stubber

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

def endsWith(suffix: String): String

final def eq(arg0: AnyRef): Boolean

macro def eqTo[T](value: T)(implicit eq: Equality[T]): T

Creates a matcher that delegates on {{org.scalactic.Equality}} so you can always customise how the values are compared Also works with value classes

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

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

final def getClass(): Class[_]

def hashCode(): Int

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

def inOrder(mocks: AnyRef*): InOrder

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

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

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

final def isInstanceOf[T0]: Boolean

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

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

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

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

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

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

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

def mockingDetails(toInspect: AnyRef): MockingDetails

val n: N

final def ne(arg0: AnyRef): Boolean

def nestedSuites: IndexedSeq[Suite]

def never: VerificationMode

final def notify(): Unit

final def notifyAll(): Unit

def only: VerificationMode

def pending: Assertion with PendingStatement

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

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

def rerunner: Option[String]

def reset(mocks: AnyRef*): Unit

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

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

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

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

def startsWith(prefix: String): String

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

def times(wantedNumberOfInvocations: Int): VerificationMode

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

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

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

def verifyNoMoreInteractions(mocks: AnyRef*): Unit

def verifyZeroInteractions(mocks: AnyRef*): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def when[T](methodCall: T)(implicit arg0: ValueClassExtractor[T]): ScalaFirstStubbing[T]

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

def withFixture(test: NoArgTest): Outcome

def withSettings(implicit defaultAnswer: DefaultAnswer): MockSettings

def anyVal[T](implicit arg0: AnyMatcher[T]): T

It was intended to be used instead of any when the argument is a value class, but any now supports value classes so it is not needed anymore

macro def eqToVal[T](value: T): T

It was intended to be used instead of eqTo when the argument is a value class, but eqTo now supports value classes so it is not needed anymore

final def execute: Unit

def isNotNull[T]: T

def isNull[T]: T

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