ArgumentMatchersSugar

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

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

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

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 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 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 matches(regex: String): String

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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 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 startsWith(prefix: String): String

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

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