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]: T

final def ==(arg0: Any): Boolean

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

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

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

object InOrder

val again: Again

val answered: Answered

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

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

val atLeastEightTimesOn: AtLeast

val atLeastFiveTimesOn: AtLeast

val atLeastFourTimesOn: AtLeast

val atLeastNineTimesOn: AtLeast

val atLeastOnceOn: AtLeast

val atLeastSevenTimesOn: AtLeast

val atLeastSixTimesOn: AtLeast

val atLeastTenTimesOn: AtLeast

val atLeastThreeTimesOn: AtLeast

val atLeastThriceOn: AtLeast

val atLeastTwiceOn: AtLeast

val atMostEightTimesOn: AtMost

val atMostFiveTimesOn: AtMost

val atMostFourTimesOn: AtMost

val atMostNineTimesOn: AtMost

val atMostOnceOn: AtMost

val atMostSevenTimesOn: AtMost

val atMostSixTimesOn: AtMost

val atMostTenTimesOn: AtMost

val atMostThreeTimesOn: AtMost

val atMostThriceOn: AtMost

val atMostTwiceOn: AtMost

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

val called: Called

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 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

val eightTimesOn: Times

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

val fiveTimesOn: Times

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

val fourTimesOn: Times

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

final def getClass(): Class[_]

def hashCode(): Int

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](implicit arg0: ClassTag[T], arg1: scala.reflect.api.JavaUniverse.TypeTag[T], defaultAnswer: DefaultAnswer): T

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

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

def mock[T <: AnyRef](name: String)(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

final def ne(arg0: AnyRef): Boolean

def nestedSuites: IndexedSeq[Suite]

val never: Never

val nineTimesOn: Times

final def notify(): Unit

final def notifyAll(): Unit

val on: On

val onceOn: Times

val onlyOn: OnlyOn

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]

val returned: Returned

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

val sevenTimesOn: Times

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

val sixTimesOn: Times

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

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

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]]

val tenTimesOn: Times

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

def testNames: Set[String]

val theRealMethod: RealMethod

val threeTimesOn: Times

val thriceOn: Times

val thrown: Thrown

def toString(): String

val twiceOn: 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]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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