ArgumentMatchersSugar

final def !=(arg0: Any): Boolean

final def ##(): Int

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

Alias for org.mockito.matchers.MacroBasedMatchers.any

final def ==(arg0: Any): Boolean

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

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

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

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

def clone(): AnyRef

def contains(substring: String): String

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

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

def finalize(): Unit

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

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

final def getClass(): Class[_]

def hashCode(): Int

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

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

final def isInstanceOf[T0]: Boolean

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

def matches(regex: String): String

val n: N

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

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

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

def startsWith(prefix: String): String

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

def isNotNull[T]: T

def isNull[T]: T