IdiomaticMockitoFixture

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 InOrder(mocks: AnyRef*)(verifications: (VerifyInOrder) ⇒ Verification): Verification

val answered: Answered.type

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](f: (T) ⇒ Boolean, desc: ⇒ String): 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(t: Times): AtLeast

val atLeastEightTimes: AtLeast

val atLeastFiveTimes: AtLeast

val atLeastFourTimes: AtLeast

val atLeastNineTimes: AtLeast

val atLeastOnce: AtLeast

val atLeastSevenTimes: AtLeast

val atLeastSixTimes: AtLeast

val atLeastTenTimes: AtLeast

val atLeastThreeTimes: AtLeast

val atLeastThrice: AtLeast

val atLeastTwice: AtLeast

def atMost(t: Times): AtMost

val atMostEightTimes: AtMost

val atMostFiveTimes: AtMost

val atMostFourTimes: AtMost

val atMostNineTimes: AtMost

val atMostOnce: AtMost

val atMostSevenTimes: AtMost

val atMostSixTimes: AtMost

val atMostTenTimes: AtMost

val atMostThreeTimes: AtMost

val atMostThrice: AtMost

val atMostTwice: AtMost

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

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

val called: Called.type

val calledAgain: CalledAgain.type

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 doubleThat(matcher: ArgumentMatcher[Double]): Double

val eightTimes: Times

def endsWith(suffix: String): String

final def eq(arg0: AnyRef): Boolean

macro def eqTo[T](value: 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

val fiveTimes: Times

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

val fourTimes: Times

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

final def getClass(): Class[_]

def hashCode(): Int

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

val ignoringStubs: IgnoringStubs.type

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

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

implicit val invocationOps: (InvocationOnMock) ⇒ InvocationOnMockOps

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.WeakTypeTag[T], defaultAnswer: DefaultAnswer, arg3: Prettifier): T

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

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

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

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

def mockingDetails(toInspect: AnyRef): MockingDetails

implicit def mockitoSerialisableEquality[T]: Equality[T]

val n: N

final def ne(arg0: AnyRef): Boolean

def nestedSuites: IndexedSeq[Suite]

val nineTimes: Times

final def notify(): Unit

final def notifyAll(): Unit

val on: On.type

val once: Times

val onlyHere: OnlyOn.type

def pending: Assertion with PendingStatement

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

val realMethod: RealMethod.type

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

def rerunner: Option[String]

def reset(mocks: AnyRef*)(implicit arg0: Prettifier): Unit

val returned: Returned.type

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

val sevenTimes: Times

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

val sixTimes: Times

def spy[T <: AnyRef](realObj: T, lenient: Boolean)(implicit arg0: ClassTag[T], arg1: scala.reflect.api.JavaUniverse.WeakTypeTag[T], arg2: Prettifier): 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]]

val tenTimes: Times

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

def testNames: Set[String]

val theRealMethod: RealMethod.type

val threeTimes: Times

val thrice: Times

val thrown: Thrown.type

def toString(): String

val twice: Times

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 verification(v: ⇒ Any): Verification

def verifyNoMoreInteractions(mocks: AnyRef*): Unit

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

final def wait(arg0: Long): Unit

final def wait(): Unit

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 finalize(): Unit

def isNotNull[T]: T

def isNull[T]: T

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