Matchers

Companion trait Matchers

object Matchers extends Matchers

Companion object that facilitates the importing of Matchers members as an alternative to mixing it the trait. One use case is to import Matchers members so you can use them in the Scala interpreter.

Source: Matchers.scala

Linear Supertypes

Matchers, Explicitly, MatcherWords, ShouldVerb, Tolerance, Assertions, TripleEquals, TripleEqualsSupport, AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

Matchers
Matchers
Explicitly
MatcherWords
ShouldVerb
Tolerance
Assertions
TripleEquals
TripleEqualsSupport
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Type Members

final class AWord extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

Definition Classes
Matchers
final class AnWord extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

Definition Classes
Matchers
sealed class AnyShouldWrapper[T] extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.
This class is used in conjunction with an implicit conversion to enable should methods to be invoked on objects of type Any.

Definition Classes
Matchers
class CheckingEqualizer[L] extends AnyRef

Definition Classes
TripleEqualsSupport
sealed class Collected extends Serializable

Attributes
protected
Definition Classes
Matchers
class DecidedByEquality[A] extends Equality[A]

Definition Classes
Explicitly
class DecidedWord extends AnyRef

Definition Classes
Explicitly
class DeterminedByEquivalence[T] extends Equivalence[T]

Definition Classes
Explicitly
class DeterminedWord extends AnyRef

Definition Classes
Explicitly
class Equalizer[L] extends AnyRef

Definition Classes
TripleEqualsSupport

final class HavePropertyMatcherGenerator extends AnyRef

This class is part of the ScalaTest matchers DSL.

This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

This class is used as the result of an implicit conversion from class Symbol, to enable symbols to be used in have ('author ("Dickens")) syntax. The name of the implicit conversion method is convertSymbolToHavePropertyMatcherGenerator.

Class HavePropertyMatcherGenerator's primary constructor takes a Symbol. The apply method uses reflection to find and access a property that has the name specified by the Symbol passed to the constructor, so it can determine if the property has the expected value passed to apply. If the symbol passed is 'title, for example, the apply method will use reflection to look for a public Java field named "title", a public method named "title", or a public method named "getTitle". If a method, it must take no parameters. If multiple candidates are found, the apply method will select based on the following algorithm:

Field	Method	"get" Method	Result
			Throws `TestFailedException`, because no candidates found
		`getTitle()`	Invokes `getTitle()`
	`title()`		Invokes `title()`
	`title()`	`getTitle()`	Invokes `title()` (this can occur when `BeanProperty` annotation is used)
`title`			Accesses field `title`
`title`		`getTitle()`	Invokes `getTitle()`
`title`	`title()`		Invokes `title()`
`title`	`title()`	`getTitle()`	Invokes `title()` (this can occur when `BeanProperty` annotation is used)

Definition Classes: Matchers

final class KeyWord extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

Definition Classes
Matchers
final class PlusOrMinusWrapper[T] extends AnyRef

Definition Classes
Tolerance
final class RegexWord extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

Definition Classes
Matchers
final class RegexWrapper extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.
This class is used in conjunction with an implicit conversion to enable withGroup and withGroups methods to be invoked on Regexs.

Definition Classes
Matchers
class ResultOfBeWordForAny[T] extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

Definition Classes
Matchers
sealed class ResultOfBeWordForCollectedAny[T] extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for InspectorsMatchers for an overview of the matchers DSL.

Definition Classes
Matchers
final class ResultOfBeWordForCollectedArray[T] extends ResultOfBeWordForCollectedAny[Array[T]]
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for InspectorsMatchers for an overview of the matchers DSL.

Definition Classes
Matchers
final class ResultOfCollectedAny[T] extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for InspectorsMatchers for an overview of the matchers DSL.

Definition Classes
Matchers
final class ResultOfContainWordForCollectedAny[T] extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for InspectorsMatchers for an overview of the matchers DSL.

Definition Classes
Matchers
final class ResultOfEndWithWordForCollectedString extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for InspectorsMatchers for an overview of the matchers DSL.

Definition Classes
Matchers
final class ResultOfEndWithWordForString extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

Definition Classes
Matchers
final class ResultOfFullyMatchWordForCollectedString extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for InspectorsMatchers for an overview of the matchers DSL.

Definition Classes
Matchers
final class ResultOfFullyMatchWordForString extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

Definition Classes
Matchers
final class ResultOfHaveWordForCollectedExtent[A] extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

Definition Classes
Matchers
final class ResultOfHaveWordForExtent[A] extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

Definition Classes
Matchers
final class ResultOfIncludeWordForCollectedString extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for InspectorsMatchers for an overview of the matchers DSL.

Definition Classes
Matchers
final class ResultOfIncludeWordForString extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

Definition Classes
Matchers
final class ResultOfNotWordForCollectedAny[T] extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for InspectorsMatchers for an overview of the matchers DSL.

Definition Classes
Matchers
final class ResultOfStartWithWordForCollectedString extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for InspectorsMatchers for an overview of the matchers DSL.

Definition Classes
Matchers
final class ResultOfStartWithWordForString extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

Definition Classes
Matchers
final class StringShouldWrapper extends AnyShouldWrapper[String] with StringShouldWrapperForVerb
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.
This class is used in conjunction with an implicit conversion to enable should methods to be invoked on Strings.

Definition Classes
Matchers
trait StringShouldWrapperForVerb extends AnyRef

Definition Classes
ShouldVerb
class TheAfterWord extends AnyRef

Definition Classes
Explicitly
final class TheSameInstanceAsPhrase extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

Definition Classes
Matchers
final class ValueWord extends AnyRef
This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

Definition Classes
Matchers

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def !==[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

Definition Classes
TripleEqualsSupport
def !==(right: Null): TripleEqualsInvocation[Null]

Definition Classes
TripleEqualsSupport
def !==[T](right: T): TripleEqualsInvocation[T]

Definition Classes
TripleEqualsSupport
final def ##(): Int

Definition Classes
AnyRef → Any
def <[T](right: T)(implicit arg0: Ordering[T]): ResultOfLessThanComparison[T]
This method enables the following syntax:
This method enables the following syntax:
```
num should (not be < (10) and not be > (17))
                   ^
```
Definition Classes
Matchers
def <=[T](right: T)(implicit arg0: Ordering[T]): ResultOfLessThanOrEqualToComparison[T]
This method enables the following syntax:
This method enables the following syntax:
```
num should (not be <= (10) and not be > (17))
                   ^
```
Definition Classes
Matchers
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def ===[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

Definition Classes
TripleEqualsSupport
def ===(right: Null): TripleEqualsInvocation[Null]

Definition Classes
TripleEqualsSupport
def ===[T](right: T): TripleEqualsInvocation[T]

Definition Classes
TripleEqualsSupport
def >[T](right: T)(implicit arg0: Ordering[T]): ResultOfGreaterThanComparison[T]
This method enables the following syntax:
This method enables the following syntax:
```
num should (not be > (10) and not be < (7))
                   ^
```
Definition Classes
Matchers
def >=[T](right: T)(implicit arg0: Ordering[T]): ResultOfGreaterThanOrEqualToComparison[T]
This method enables the following syntax:
This method enables the following syntax:
```
num should (not be >= (10) and not be < (7))
                   ^
```
Definition Classes
Matchers
def a[T](implicit arg0: ClassTag[T]): ResultOfATypeInvocation[T]
This method enables the following syntax:
This method enables the following syntax:
```
a [RuntimeException] should be thrownBy { ... }
^
```
Definition Classes
Matchers
val a: AWord
This field enables the following syntax:
This field enables the following syntax:
```
badBook should not be a ('goodRead)
                      ^
```
Definition Classes
Matchers
val after: TheAfterWord

Definition Classes
Explicitly
def all(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]
This method enables the following syntax for String:
This method enables the following syntax for String:
```
all(str) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def all[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]
This method enables the following syntax for java.util.Map:
This method enables the following syntax for java.util.Map:
```
all(jmap) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def all[K, V, MAP[k, v] <: GenMap[k, v]](xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]
This method enables the following syntax for scala.collection.GenMap:
This method enables the following syntax for scala.collection.GenMap:
```
all(map) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def all[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]
This method enables the following syntax:
This method enables the following syntax:
```
all(xs) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def allElementsOf[R](elements: GenTraversable[R]): ResultOfAllElementsOfApplication
This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) should contain (allElementsOf(1, 2))
                              ^
```
Definition Classes
Matchers
def allOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfAllOfApplication
This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) should contain (allOf(1, 2))
                              ^
```
Definition Classes
Matchers
def an[T](implicit arg0: ClassTag[T]): ResultOfAnTypeInvocation[T]
This method enables the following syntax:
This method enables the following syntax:
```
an [Exception] should be thrownBy { ... }
^
```
Definition Classes
Matchers
val an: AnWord
This field enables the following syntax:
This field enables the following syntax:
```
badBook should not be an (excellentRead)
                      ^
```
Definition Classes
Matchers
final def asInstanceOf[T0]: T0

Definition Classes
Any
macro def assert(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

Definition Classes
Assertions
macro def assert(condition: Boolean)(implicit prettifier: Prettifier, pos: Position): Assertion

Definition Classes
Assertions
macro def assertCompiles(code: String)(implicit pos: Position): Assertion

Definition Classes
Assertions
macro def assertDoesNotCompile(code: String)(implicit pos: Position): Assertion

Definition Classes
Assertions
def assertResult(expected: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

Definition Classes
Assertions
def assertResult(expected: Any, clue: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

Definition Classes
Assertions
def assertThrows[T <: AnyRef](f: ⇒ Any)(implicit classTag: ClassTag[T], pos: Position): Assertion

Definition Classes
Assertions
macro def assertTypeError(code: String)(implicit pos: Position): Assertion

Definition Classes
Assertions
macro def assume(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

Definition Classes
Assertions
macro def assume(condition: Boolean)(implicit prettifier: Prettifier, pos: Position): Assertion

Definition Classes
Assertions
def atLeast(num: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]
This method enables the following syntax for String:
This method enables the following syntax for String:
```
atLeast(1, str) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def atLeast[K, V, JMAP[k, v] <: Map[k, v]](num: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]
This method enables the following syntax for java.util.Map:
This method enables the following syntax for java.util.Map:
```
atLeast(1, jmap) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def atLeast[K, V, MAP[k, v] <: GenMap[k, v]](num: Int, xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]
This method enables the following syntax for scala.collection.GenMap:
This method enables the following syntax for scala.collection.GenMap:
```
atLeast(1, map) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def atLeast[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]
This method enables the following syntax:
This method enables the following syntax:
```
atLeast(1, xs) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def atLeastOneElementOf(elements: GenTraversable[Any]): ResultOfAtLeastOneElementOfApplication
This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) should contain (atLeastOneElementOf (List(1, 2)))
                              ^
```
Definition Classes
Matchers
def atLeastOneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfAtLeastOneOfApplication
This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) should contain (atLeastOneOf(1, 2))
                              ^
```
Definition Classes
Matchers
def atMost(num: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]
This method enables the following syntax for String:
This method enables the following syntax for String:
```
atMost(3, str) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def atMost[K, V, JMAP[k, v] <: Map[k, v]](num: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]
This method enables the following syntax for java.util.Map:
This method enables the following syntax for java.util.Map:
```
atMost(3, jmap) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def atMost[K, V, MAP[k, v] <: GenMap[k, v]](num: Int, xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]
This method enables the following syntax for scala.collection.GenMap:
This method enables the following syntax for scala.collection.GenMap:
```
atMost(3, map) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def atMost[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]
This method enables the following syntax:
This method enables the following syntax:
```
atMost(3, xs) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def atMostOneElementOf[R](elements: GenTraversable[R]): ResultOfAtMostOneElementOfApplication
This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) should contain (atMostOneElementOf (List(1, 2)))
                              ^
```
Definition Classes
Matchers
def atMostOneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfAtMostOneOfApplication
This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) should contain (atMostOneOf(1, 2))
                              ^
```
Definition Classes
Matchers
val be: BeWord

Definition Classes
MatcherWords
def between(from: Int, upTo: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]
This method enables the following syntax for String:
This method enables the following syntax for String:
```
between(1, 3, str) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def between[K, V, JMAP[k, v] <: Map[k, v]](from: Int, upTo: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]
This method enables the following syntax for java.util.Map:
This method enables the following syntax for java.util.Map:
```
between(1, 3, jmap) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def between[E, C[_]](from: Int, upTo: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]
This method enables the following syntax:
This method enables the following syntax:
```
between(1, 3, xs) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def cancel(cause: Throwable)(implicit pos: Position): Nothing

Definition Classes
Assertions
def cancel(message: String, cause: Throwable)(implicit pos: Position): Nothing

Definition Classes
Assertions
def cancel(message: String)(implicit pos: Position): Nothing

Definition Classes
Assertions
def cancel()(implicit pos: Position): Nothing

Definition Classes
Assertions
def clone(): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
val compile: CompileWord

Definition Classes
MatcherWords
val contain: ContainWord

Definition Classes
MatcherWords
def convertEquivalenceToAToBConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: <:<[A, B]): CanEqual[A, B]

Definition Classes
TripleEquals → TripleEqualsSupport
def convertEquivalenceToBToAConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: <:<[B, A]): CanEqual[A, B]

Definition Classes
TripleEquals → TripleEqualsSupport
implicit def convertNumericToPlusOrMinusWrapper[T](pivot: T)(implicit arg0: Numeric[T]): PlusOrMinusWrapper[T]

Definition Classes
Tolerance
implicit def convertSymbolToHavePropertyMatcherGenerator(symbol: Symbol)(implicit prettifier: Prettifier, pos: Position): HavePropertyMatcherGenerator
This implicit conversion method converts a Symbol to a HavePropertyMatcherGenerator, to enable the symbol to be used with the have ('author ("Dickens")) syntax.
This implicit conversion method converts a Symbol to a HavePropertyMatcherGenerator, to enable the symbol to be used with the have ('author ("Dickens")) syntax.

Definition Classes
Matchers
implicit def convertToAnyShouldWrapper[T](o: T)(implicit pos: Position, prettifier: Prettifier): AnyShouldWrapper[T]
Implicitly converts an object of type T to a AnyShouldWrapper[T], to enable should methods to be invokable on that object.
Implicitly converts an object of type T to a AnyShouldWrapper[T], to enable should methods to be invokable on that object.

Definition Classes
Matchers
def convertToCheckingEqualizer[T](left: T): CheckingEqualizer[T]

Definition Classes
TripleEquals → TripleEqualsSupport
implicit def convertToEqualizer[T](left: T): Equalizer[T]

Definition Classes
TripleEquals → TripleEqualsSupport
implicit def convertToRegexWrapper(o: Regex): RegexWrapper
Implicitly converts an object of type scala.util.matching.Regex to a RegexWrapper, to enable withGroup and withGroups methods to be invokable on that object.
Implicitly converts an object of type scala.util.matching.Regex to a RegexWrapper, to enable withGroup and withGroups methods to be invokable on that object.

Definition Classes
Matchers
implicit def convertToStringShouldWrapper(o: String)(implicit pos: Position, prettifier: Prettifier): StringShouldWrapper
Implicitly converts an object of type java.lang.String to a StringShouldWrapper, to enable should methods to be invokable on that object.
Implicitly converts an object of type java.lang.String to a StringShouldWrapper, to enable should methods to be invokable on that object.

Definition Classes
Matchers
implicit def convertToStringShouldWrapperForVerb(o: String)(implicit position: Position): StringShouldWrapperForVerb

Definition Classes
ShouldVerb
val decided: DecidedWord

Definition Classes
Explicitly
def defaultEquality[A]: Equality[A]

Definition Classes
TripleEqualsSupport
val defined: DefinedWord

Definition Classes
MatcherWords
def definedAt[T](right: T): ResultOfDefinedAt[T]
This method enables the following syntax:
This method enables the following syntax:
```
list should (not be definedAt (7) and not be definedAt (9))
                    ^
```
Definition Classes
Matchers
val determined: DeterminedWord

Definition Classes
Explicitly
val empty: EmptyWord

Definition Classes
MatcherWords
val endWith: EndWithWord

Definition Classes
MatcherWords
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equal(o: Null): Matcher[AnyRef]
This method enables syntax such as the following:
This method enables syntax such as the following:
```
result should equal (null)
              ^
```
Definition Classes
Matchers
def equal[T](spread: Spread[T]): Matcher[T]
This method enables syntax such as the following:
This method enables syntax such as the following:
```
result should equal (100 +- 1)
              ^
```
Definition Classes
Matchers
def equal(right: Any): MatcherFactory1[Any, Equality]

Definition Classes
MatcherWords
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def every(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]
This method enables the following syntax for String:
This method enables the following syntax for String:
```
every(str) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def every[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]
This method enables the following syntax for java.util.Map:
This method enables the following syntax for java.util.Map:
```
every(jmap) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def every[K, V, MAP[k, v] <: Map[k, v]](xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]
This method enables the following syntax for scala.collection.GenMap:
This method enables the following syntax for scala.collection.GenMap:
```
every(map) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def every[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]
This method enables the following syntax:
This method enables the following syntax:
```
every(xs) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def exactly(num: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]
This method enables the following syntax for String:
This method enables the following syntax for String:
```
exactly(str) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def exactly[K, V, JMAP[k, v] <: Map[k, v]](num: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]
This method enables the following syntax for java.util.Map:
This method enables the following syntax for java.util.Map:
```
exactly(jmap) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def exactly[K, V, MAP[k, v] <: GenMap[k, v]](num: Int, xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]
This method enables the following syntax for scala.collection.GenMap:
This method enables the following syntax for scala.collection.GenMap:
```
exactly(map) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def exactly[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]
This method enables the following syntax:
This method enables the following syntax:
```
exactly(xs) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
val exist: ExistWord

Definition Classes
MatcherWords
def fail(cause: Throwable)(implicit pos: Position): Nothing

Definition Classes
Assertions
def fail(message: String, cause: Throwable)(implicit pos: Position): Nothing

Definition Classes
Assertions
def fail(message: String)(implicit pos: Position): Nothing

Definition Classes
Assertions
def fail()(implicit pos: Position): Nothing

Definition Classes
Assertions
def finalize(): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
val fullyMatch: FullyMatchWord

Definition Classes
MatcherWords
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@native()
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@native()
val have: HaveWord

Definition Classes
MatcherWords
def inOrder(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfInOrderApplication
This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) should contain (inOrder(1, 2))
                              ^
```
Definition Classes
Matchers
def inOrderElementsOf[R](elements: GenTraversable[R]): ResultOfInOrderElementsOfApplication
This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) should contain (inOrderElementsOf List(1, 2))
                              ^
```
Definition Classes
Matchers
def inOrderOnly[T](firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfInOrderOnlyApplication
This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) should contain (inOrderOnly(1, 2))
                              ^
```
Definition Classes
Matchers
val include: IncludeWord

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

Definition Classes
Assertions
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
val key: KeyWord
This field enables the following syntax:
This field enables the following syntax:
```
map should not contain key (10)
                       ^
```
Definition Classes
Matchers
val length: LengthWord

Definition Classes
MatcherWords
def lowPriorityTypeCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], ev: <:<[A, B]): CanEqual[A, B]

Definition Classes
TripleEquals → TripleEqualsSupport
val matchPattern: MatchPatternWord

Definition Classes
MatcherWords
def message(expectedMessage: String): ResultOfMessageWordApplication
This method enables the following syntax:
This method enables the following syntax:
```
exception should not have message ("file not found")
                          ^
```
Definition Classes
Matchers
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def no(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]
This method enables the following syntax for String:
This method enables the following syntax for String:
```
no(str) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def no[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Entry[K, V]]
This method enables the following syntax for java.util.Map:
This method enables the following syntax for java.util.Map:
```
no(jmap) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def no[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]
This method enables the following syntax:
This method enables the following syntax:
```
no(xs) should fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
Matchers
def noElementsOf(elements: GenTraversable[Any]): ResultOfNoElementsOfApplication
This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) should contain (noElementsOf List(1, 2))
                              ^
```
Definition Classes
Matchers
def noException(implicit pos: Position): NoExceptionWord

Definition Classes
MatcherWords
def noneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfNoneOfApplication
This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) should contain (noneOf(1, 2))
                              ^
```
Definition Classes
Matchers
val not: NotWord

Definition Classes
MatcherWords
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@native()
def of[T](implicit ev: ClassTag[T]): ResultOfOfTypeInvocation[T]
This method enables syntax such as the following:
This method enables syntax such as the following:
```
book should have (message ("A TALE OF TWO CITIES") (of [Book]), title ("A Tale of Two Cities"))
                                                    ^
```
Definition Classes
Matchers
def oneElementOf(elements: GenTraversable[Any]): ResultOfOneElementOfApplication
This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) should contain (oneElementOf (List(1, 2)))
                              ^
```
Definition Classes
Matchers
def oneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfOneOfApplication
This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) should contain (oneOf(1, 2))
                              ^
```
Definition Classes
Matchers
def only(xs: Any*)(implicit pos: Position): ResultOfOnlyApplication
This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) should contain (only(1, 2))
                              ^
```
Definition Classes
Matchers
def pending: Assertion with PendingStatement

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

Definition Classes
Assertions
val readable: ReadableWord

Definition Classes
MatcherWords
val regex: RegexWord
This field enables the following syntax:
This field enables the following syntax:
```
"eight" should not fullyMatch regex ("""(-)?(\d+)(\.\d*)?""".r)
                              ^
```
Definition Classes
Matchers
val size: SizeWord

Definition Classes
MatcherWords
val sorted: SortedWord

Definition Classes
MatcherWords
val startWith: StartWithWord

Definition Classes
MatcherWords
final val succeed: Assertion

Definition Classes
Assertions
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def the[T](implicit arg0: ClassTag[T], pos: Position): ResultOfTheTypeInvocation[T]
This method enables the following syntax:
This method enables the following syntax:
```
the [FileNotFoundException] should be thrownBy { ... }
^
```
Definition Classes
Matchers
def theSameElementsAs(xs: GenTraversable[_]): ResultOfTheSameElementsAsApplication
This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) should contain (theSameElementsAs(List(1, 2, 3)))
                              ^
```
Definition Classes
Matchers
def theSameElementsInOrderAs(xs: GenTraversable[_]): ResultOfTheSameElementsInOrderAsApplication
This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) should contain (theSameElementsInOrderAs(List(1, 2)))
                              ^
```
Definition Classes
Matchers
val theSameInstanceAs: TheSameInstanceAsPhrase
This field enables the following syntax:
This field enables the following syntax:
```
oneString should not be theSameInstanceAs (anotherString)
                        ^
```
Definition Classes
Matchers
def thrownBy(fun: ⇒ Any): ResultOfThrownByApplication
This method enables the following syntax:
This method enables the following syntax:
```
a [RuntimeException] should be thrownBy {...}
                               ^
```
Definition Classes
Matchers
def toString(): String

Definition Classes
AnyRef → Any
val typeCheck: TypeCheckWord

Definition Classes
MatcherWords
def typeCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], ev: <:<[B, A]): CanEqual[A, B]

Definition Classes
TripleEquals → TripleEqualsSupport
implicit def unconstrainedEquality[A, B](implicit equalityOfA: Equality[A]): CanEqual[A, B]

Definition Classes
TripleEquals → TripleEqualsSupport
val value: ValueWord
This field enables the following syntax:
This field enables the following syntax:
```
map should not contain value (10)
                       ^
```
Definition Classes
Matchers
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
def withClue[T](clue: Any)(fun: ⇒ T): T

Definition Classes
Assertions
val writable: WritableWord

Definition Classes
MatcherWords

Deprecated Value Members

def conversionCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], cnv: (B) ⇒ A): CanEqual[A, B]

Definition Classes
TripleEquals → TripleEqualsSupport
Annotations
@deprecated
Deprecated
(Since version 3.1.0) The conversionCheckedConstraint method has been deprecated and will be removed in a future version of ScalaTest. It is no longer needed now that the deprecation period of ConversionCheckedTripleEquals has expired. It will not be replaced.
def convertEquivalenceToAToBConversionConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: (A) ⇒ B): CanEqual[A, B]

Definition Classes
TripleEquals → TripleEqualsSupport
Annotations
@deprecated
Deprecated
(Since version 3.1.0) The convertEquivalenceToAToBConversionConstraint method has been deprecated and will be removed in a future version of ScalaTest. It is no longer needed now that the deprecation period of ConversionCheckedTripleEquals has expired. It will not be replaced.
def convertEquivalenceToBToAConversionConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: (B) ⇒ A): CanEqual[A, B]

Definition Classes
TripleEquals → TripleEqualsSupport
Annotations
@deprecated
Deprecated
(Since version 3.1.0) The convertEquivalenceToBToAConversionConstraint method has been deprecated and will be removed in a future version of ScalaTest. It is no longer needed now that the deprecation period of ConversionCheckedTripleEquals has expired. It will not be replaced.
def lowPriorityConversionCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], cnv: (A) ⇒ B): CanEqual[A, B]

Definition Classes
TripleEquals → TripleEqualsSupport
Annotations
@deprecated
Deprecated
(Since version 3.1.0) The lowPriorityConversionCheckedConstraint method has been deprecated and will be removed in a future version of ScalaTest. It is no longer needed now that the deprecation period of ConversionCheckedTripleEquals has expired. It will not be replaced.

Packages

Matchers

Companion trait Matchers

object Matchers extends Matchers

Type Members

Value Members

Deprecated Value Members

Inherited from Matchers

Inherited from Explicitly

Inherited from MatcherWords

Inherited from ShouldVerb

Inherited from Tolerance

Inherited from Assertions

Inherited from TripleEquals

Inherited from TripleEqualsSupport

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

Matchers 

Companion trait Matchers

object Matchers extends Matchers

Type Members

Value Members

Deprecated Value Members

Inherited from Matchers

Inherited from Explicitly

Inherited from MatcherWords

Inherited from ShouldVerb

Inherited from Tolerance

Inherited from Assertions

Inherited from TripleEquals

Inherited from TripleEqualsSupport

Inherited from AnyRef

Inherited from Any

Ungrouped

Matchers