Package

org.specs2

matcher

Permalink

package matcher

Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. matcher
  2. ReturnsSyntax
  3. ExpectationsCreation
  4. MatchResultStackTrace
  5. AnyRef
  6. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. trait AdaptableMatcher[T] extends Matcher[T]

    Permalink

    Inherit this trait to provide a Matcher where both the actual and the expected values can be adapted with a function.

  2. case class AlwaysMatcher[T]() extends Matcher[T] with Product with Serializable

    Permalink

    This matcher always matches any value of type T

  3. class AndMatch[T] extends MatchResult[T]

    Permalink
  4. class AndNotMatch[T] extends MatchResult[T]

    Permalink
  5. trait AnyBeHaveMatchers extends BeHaveMatchers

    Permalink

    This trait allows to write expressions like

    This trait allows to write expressions like

    1 must be equalTo(1)

  6. trait AnyMatchers extends AnyBaseMatchers with AnyBeHaveMatchers

    Permalink

    This trait provides matchers which are applicable to any type of value

  7. class BeCloseTo[T] extends Matcher[T]

    Permalink
  8. class BeEqualTo extends EqualityMatcher[Any]

    Permalink

    Equality Matcher

  9. case class BeEqualTypedValueCheck[T](expected: T)(implicit evidence$4: Diffable[T]) extends ValueCheck[T] with Product with Serializable

    Permalink

    ValueCheck for a typed expected value.

    ValueCheck for a typed expected value. It uses the BeTypedEqualTo matcher

  10. case class BeEqualValueCheck[T](expected: Any) extends ValueCheck[T] with Product with Serializable

    Permalink

    ValueCheck for an untyped expected value.

    ValueCheck for an untyped expected value. It uses the BeEqualTo matcher

  11. class BeLessThan[T] extends Matcher[T]

    Permalink
  12. class BeLessThanOrEqualTo[T] extends Matcher[T]

    Permalink
  13. class BeMatching extends Matcher[String]

    Permalink
    Attributes
    protected[org.specs2]
  14. class BeMatchingPattern extends BeMatching

    Permalink
    Attributes
    protected[org.specs2]
  15. class BeMatchingRegex extends BeMatching

    Permalink
  16. class BeNull[T] extends Matcher[T]

    Permalink
  17. case class BeOneOf[T](t: Seq[T]) extends Matcher[T] with Product with Serializable

    Permalink
  18. class BeSignificantlyCloseTo[T] extends Matcher[T]

    Permalink
  19. class BeTheSameAs[T <: AnyRef] extends Matcher[T]

    Permalink
  20. class BeTrueMatcher extends Matcher[Boolean]

    Permalink

    Matcher for a boolean value which must be true

  21. class BeTypedEqualTo[T] extends EqualityMatcher[T]

    Permalink

    Typed equality Matcher with fallback comparison results

  22. case class BetweenMatcher[T](t1: T, t2: T, includeStart: Boolean = true, includeEnd: Boolean = true)(implicit evidence$49: (T) ⇒ Ordered[T]) extends Matcher[T] with Product with Serializable

    Permalink
  23. case class CanHaveDelta[S](n: S)(implicit evidence$33: Numeric[S]) extends Product with Serializable

    Permalink

    transient class allowing the creation of a delta

  24. case class ContainWithResult[T](check: ValueCheck[T], timesMin: Option[Times] = Some(1.times), timesMax: Option[Times] = None, checkAll: Boolean = true) extends Matcher[GenTraversableOnce[T]] with Product with Serializable

    Permalink
  25. case class ContainWithResultSeq[T](checks: Seq[ValueCheck[T]], containsAtLeast: Boolean = true, containsAtMost: Boolean = false, eachCheck: Boolean = false, checkOrder: Boolean = false, negate: Boolean = false) extends Matcher[GenTraversableOnce[T]] with Product with Serializable

    Permalink
  26. case class DataTable(titles: Seq[String], rows: Seq[DataTableRow]) extends Product with Serializable

    Permalink
  27. case class DataTableRow(cells: Seq[String], result: Result) extends Product with Serializable

    Permalink
  28. trait DataTables extends ExpectationsCreation

    Permalink

    This trait provides implicit definitions and types to create DataTables.

    This trait provides implicit definitions and types to create DataTables.

    A DataTable has a header defining column names and rows holding values. It is possible to apply a function taking the row values and returning a MatchResult.

    A TableHeader is defined by separating the column names with '|': "a" | "b" | "c"

    A DataRow is defined by separating the row values with '!': 1 ! 2 ! 3

    Note that the '!' method can conflict with the creation of Examples when the value is a string. In that case it is possible to use the '!!! method to disambiguate:

    "1" !! "2" ! "3"

    In that case the first column of the header can also be defined with '||' for pure symmetry reasons:

    "a" || "b" | "c" "1" !! "2" ! "3"

    See also

    org.specs2.matcher.DataTablesSpec for examples

  29. trait EitherMatchers extends EitherBaseMatchers with EitherBeHaveMatchers

    Permalink

    Matchers for the Either datatype

  30. class EqualityMatcher[T] extends AdaptableMatcher[T]

    Permalink
  31. trait EventuallyMatchers extends EventuallyResults

    Permalink

    This trait adds the possibility to retry a given matcher until it succeeds.

    This trait adds the possibility to retry a given matcher until it succeeds.

    This was contributed by @robey (http://robey.lag.net)

  32. trait ExceptionMatchers extends ExceptionBaseMatchers with ExceptionBeHaveMatchers

    Permalink

    These matchers can be used to check if exceptions are thrown or not

  33. class Expectable[+T] extends AnyRef

    Permalink

    The Expectable class models anything which can be checked by applying a Matcher

    The Expectable class models anything which can be checked by applying a Matcher

    It stores a value which is only evaluated when necessary and an optional additional description for that value.

    The Expectable object is responsible for creating its own description, based on the value toString method and and an additional description.

  34. trait Expectations extends ExpectationsCreation with TypedEqual with ExpectationsDescription

    Permalink

    This trait provides implicit definitions to transform any value into an Expectable

  35. trait ExpectationsCreation extends MatchResultStackTrace

    Permalink

    Base trait to create expectations

  36. trait ExpectationsDescription extends ExpectationsCreation

    Permalink
  37. trait FutureMatchers extends FutureBaseMatchers

    Permalink

    This trait is for transforming matchers of values to matchers of Futures

  38. case class LeftCheckedMatcher[T](check: ValueCheck[T]) extends OptionLikeCheckedMatcher[[a]Either[a, _], T, T] with Product with Serializable

    Permalink
  39. case class LeftMatcher[T]() extends OptionLikeMatcher[[a]Either[a, _], T, T] with Product with Serializable

    Permalink
  40. trait MapMatchers extends MapBaseMatchers with MapBeHaveMatchers

    Permalink

    Matchers for Maps

  41. case class MatchFailure[T] extends MatchResult[T] with Product with Serializable

    Permalink
  42. class MatchFailureException[T] extends FailureException with MatchResultException[T]

    Permalink

    this class allows to throw a match failure result in an Exception

  43. case class MatchPending[T] extends MatchResult[T] with Product with Serializable

    Permalink
  44. class MatchPendingException[T] extends PendingException with MatchResultException[T]

    Permalink

    this class allows to throw a pending result in an Exception

  45. trait MatchResult[+T] extends ResultLike

    Permalink

    Result of a Match.

    Result of a Match.

    A MatchResult contains several information about a match on an expectable:

    - the expectable value, to allow the chaining of matches - a pair of messages ok message / ko message to allow the easy creation of the negation of a match

    A MatchResult can be transformed to a simple Result object to be the body of an Example.

    There are different kinds of MatchResults, some of them being only created to support English-like combination of Matchers:

    1 must be equalTo(1) and not be equalTo(2)

    In an Expectation like the one above, there is a left to right evaluation:

    1. be is a NeutralMatcher, returning a NeutralMatch doing nothing yet, just storing the expectable

    2. equalTo(1) is a real Matcher which is applied to the NeutralMatch MatchResult thanks to an implicit definition in the BeHaveAnyMatchers trait. This yields a MatchSuccess result

    3. not creates a NotMatcher and can be and-ed with the previous MatchSuccess to yield a AndMatch(MatchSuccess, NotMatch), with NotMatch being the result of applying the NotMatcher to the expectable. This AndMatch is evaluated to create a AndNotMatch(MatchSuccess, MatchSkip)

    Basically this is like forming an evaluation structure which will be resolved when the next 'real' matcher will arrive

    4. the AndNotMatch get nows it be method called with the equalTo Matcher. This results in equalTo being applied to the AndNotMatch, effectively doing: MatchSuccess and MatchSkip.apply(equalTo(2).not), which is MatchSuccess and expectable.applyMatcher(equalTo(2).not) which is MatchSuccess

    See also

    org.specs2.matcher.BeHaveMatchersSpec for examples

  46. trait MatchResultCombinators extends MatchResultLogicalCombinators with ResultLogicalCombinators

    Permalink

    This trait provides logical operators to combine match results where potentially a MatchResult expression throws an Exception, either because it is an error or because it is a ThrownExpectation

  47. trait MatchResultException[T] extends AnyRef

    Permalink
  48. trait MatchResultImplicits extends AnyRef

    Permalink

    Implicit conversions for MatchResults

  49. trait MatchResultLogicalCombinators extends Expectations

    Permalink
  50. trait MatchResultStackTrace extends AnyRef

    Permalink

    this trait allows to fill-in stack traces on match results for precise location

  51. case class MatchSkip[T] extends MatchResult[T] with Product with Serializable

    Permalink
  52. class MatchSkipException[T] extends SkipException with MatchResultException[T]

    Permalink

    this class allows to throw a skipped match result in an Exception

  53. case class MatchSuccess[T] extends MatchResult[T] with Product with Serializable

    Permalink

    The signature of this class constructor is unusual, with a useless implicit parameter.

    The signature of this class constructor is unusual, with a useless implicit parameter.

    This is actually here to avoid overloading conflicts with the apply method in the companion object

  54. trait Matcher[-T] extends AnyRef

    Permalink

    The Matcher trait is the base trait for any Matcher.

    The Matcher trait is the base trait for any Matcher.

    This trait can be extended to provide an appropriate apply method that will check an expectable value a: Expectable[T].

    The result of a match is a MatchResult object (@see MatchResult).

    Matchers can be composed.

    Implementation notes:

    • the parameter to the apply method must be a by-name parameter. This allows some values to be evaluated only when necessary.
    • However in the implementation of the apply function, it must be taken care of not evaluating the parameter twice. Assigning it to a val is the solution to this issue.
  55. trait MatcherZipOperators extends ExpectationsCreation

    Permalink

    This trait provides 'zip' operators to create matchers on tuples based on "zipped" matchers on fields

  56. trait MatcherZipOperatorsCodeGeneration extends AnyRef

    Permalink

    Generation code for the MatcherZipOperators trait

  57. trait Matchers extends AnyMatchers with BeHaveMatchers with TraversableMatchers with MapMatchers with StringMatchers with ExceptionMatchers with NumericMatchers with OptionMatchers with EitherMatchers with TryMatchers with EventuallyMatchers with FutureMatchers with MatchersImplicits with ValueChecks with LanguageFeatures

    Permalink

    Trait aggregating the most common specs2 matchers

  58. trait Matchers1 extends AnyBaseMatchers with TraversableBaseMatchers with StringBaseMatchers with ExceptionBaseMatchers with NumericBaseMatchers with OptionBaseMatchers with EitherBaseMatchers with TryBaseMatchers with EventuallyMatchers with FutureBaseMatchers with ValueChecksBase

    Permalink
  59. trait MatchersCreation extends AnyRef

    Permalink
  60. trait MatchersImplicits extends MatchResultCombinators with MatcherZipOperators with MatchResultImplicits with ResultImplicits with MatchersCreation with SequenceMatchersCreation

    Permalink

    This trait provides implicit definitions from MatchResults and Booleans to Results.

    This trait provides implicit definitions from MatchResults and Booleans to Results.

    It also allows to:

    - create matchers from functions - create matchers for seqs and sets from single matchers

  61. class MustExpectable[T] extends Expectable[T]

    Permalink

    This kind of expectable can be followed by the verb must to apply a matcher:

    This kind of expectable can be followed by the verb must to apply a matcher:

    1 must beEqualTo(1)

    For convenience, several mustMatcher methods have also been defined as shortcuts to equivalent:

    a must matcher

  62. trait MustExpectations extends MustExpectations1 with ExpectationsDescription with TypedEqual

    Permalink

    This trait provides implicit definitions to transform any value into a MustExpectable

  63. trait MustMatchers extends Matchers with MustExpectations

    Permalink
  64. trait MustThrownExpectables extends MustExpectations with MustThrownExpectations1

    Permalink
  65. trait MustThrownExpectations extends MustThrownExpectables with StandardResults with StandardMatchResults

    Permalink

    This trait provides implicit definitions to transform any value into a MustExpectable, throwing exceptions when a match fails

  66. trait MustThrownExpectationsCreation extends ThrownExpectationsCreation with MustExpectationsCreation

    Permalink
  67. trait MustThrownMatchers extends Matchers with MustThrownExpectations

    Permalink
  68. case class NeutralMatch[T] extends MatchResult[T] with Product with Serializable

    Permalink
  69. class NeutralMatcher[T] extends Matcher[T]

    Permalink

    This special matcher always return a NeutralMatch MatchResult (an implicit Success)

  70. case class NeverMatcher[T]() extends Matcher[T] with Product with Serializable

    Permalink

    This matcher never matches any value of type T

  71. trait NoExpectationsDescription extends ExpectationsDescription

    Permalink
  72. trait NoMatchResultStackTrace extends MatchResultStackTrace

    Permalink

    this trait doesn't fill-in stack traces

  73. trait NoMatcherZipOperatorsImplicits extends MatcherZipOperators

    Permalink

    This trait can be mixed in to remove the implicit definitions for zipping matchers

  74. trait NoMatcherZipOperatorsImplicitsCodeGeneration extends AnyRef

    Permalink

    code generation for the NoMatcherZipOperatorsImplicits trait

  75. trait NoMustExpectations extends MustExpectations

    Permalink

    This trait can be used to remove aka and must methods on any value

  76. trait NoShouldExpectations extends ShouldExpectations

    Permalink

    This trait can be used to remove aka and should methods on any value

  77. trait NoThrownExpectations extends Expectations

    Permalink

    This trait can be used to cancel the effect of thrown expectations.

    This trait can be used to cancel the effect of thrown expectations.

    For example it can be mixed-in a mutable.Specification so that no exception is thrown on failure

  78. trait NoTypedEqual extends TypedEqual

    Permalink

    This trait can be used to suppress the TypedEqual implicit

  79. case class NotMatch[T] extends MatchResult[T] with Product with Serializable

    Permalink
  80. class NotMatcher[T] extends Matcher[T]

    Permalink

    This special matcher always return a NotMatch MatchResult.

    This special matcher always return a NotMatch MatchResult. It will negate the next match applied to it.

  81. trait NumericMatchers extends NumericBaseMatchers with NumericBeHaveMatchers

    Permalink

    Matchers for Numerical values

  82. trait OperationMatchers extends ValueChecks

    Permalink

    Matchers for Operation values

  83. class OptionLikeCheckedMatcher[F[_], T, U] extends Matcher[F[T]]

    Permalink
  84. class OptionLikeMatcher[F[_], T, U] extends Matcher[F[T]]

    Permalink
  85. trait OptionMatchers extends OptionBaseMatchers with OptionBeHaveMatchers with ValueChecks

    Permalink

    Matchers for Options

  86. class OrMatch[T] extends MatchResult[T]

    Permalink
  87. class OrNotMatch[T] extends MatchResult[T]

    Permalink
  88. class OrderingMatcher[T] extends Matcher[Seq[T]]

    Permalink
  89. case class PlusOrMinus[S](n: S, delta: S) extends Product with Serializable

    Permalink

    class representing a numeric range

  90. trait ResultImplicits extends ExpectationsCreation

    Permalink
  91. trait ResultMatchers extends ResultBaseMatchers with ResultBeHaveMatchers

    Permalink

    Matchers for Results

  92. implicit class Returns[T] extends AnyRef

    Permalink
    Definition Classes
    ReturnsSyntax
  93. trait ReturnsSyntax extends ExpectationsCreation

    Permalink

    Those definitions help specifying the result messages for matchers

  94. case class RightCheckedMatcher[T](check: ValueCheck[T]) extends OptionLikeCheckedMatcher[[a]Either[_, a], T, T] with Product with Serializable

    Permalink
  95. case class RightMatcher[T]() extends OptionLikeMatcher[[a]Either[_, a], T, T] with Product with Serializable

    Permalink
  96. trait Scope extends AnyRef

    Permalink

    This trait represents any Scope that is used to enclose expectations which might be thrown

  97. trait SequenceMatchersCreation extends ExpectationsCreation with ResultImplicits

    Permalink
  98. class ShouldExpectable[T] extends Expectable[T]

    Permalink

    This kind of expectable can be followed by the verb should to apply a matcher:

    This kind of expectable can be followed by the verb should to apply a matcher:

    1 should beEqualTo(1)

    For convenience, several shouldMatcher methods have also been defined as shortcuts to equivalent:

    a should matcher

  99. trait ShouldExpectations extends Expectations

    Permalink

    This trait provides implicit definitions to transform any value into a ShouldExpectable

  100. trait ShouldMatchers extends Matchers with ShouldExpectations

    Permalink
  101. trait ShouldThrownExpectables extends ThrownExpectations with ShouldExpectations

    Permalink
  102. trait ShouldThrownExpectations extends ShouldThrownExpectables with StandardResults with StandardMatchResults

    Permalink

    This trait provides implicit definitions to transform any value into a ShouldExpectable, throwing exceptions when a match fails

  103. trait ShouldThrownMatchers extends Matchers with ShouldThrownExpectations

    Permalink
  104. case class SignificantFigures(number: Int) extends Product with Serializable

    Permalink
  105. case class SignificantTarget[T](target: T, significantFigures: SignificantFigures)(implicit evidence$48: Numeric[T]) extends Product with Serializable

    Permalink
  106. class SizedCheckedMatcher[T] extends Matcher[T]

    Permalink
  107. class SizedMatcher[T] extends Matcher[T]

    Permalink
  108. case class SomeCheckedMatcher[T](check: ValueCheck[T]) extends OptionLikeCheckedMatcher[Option, T, T] with Product with Serializable

    Permalink
  109. case class SomeMatcher[T]() extends OptionLikeMatcher[Option, T, T] with Product with Serializable

    Permalink
  110. trait StandardMatchResults extends ExpectationsCreation

    Permalink

    This trait can be used in conjunction with Pattern matchers:

    This trait can be used in conjunction with Pattern matchers:

    List(1, 2) must be like { case List(a, b) => ok } List(1, 2) must be like { case List(a, b) => ko("unexpected") }

  111. trait StoredExpectations extends Expectations

    Permalink

    This trait evaluates expectations and stores them in a local variable for further usage

  112. case class StringMatcher(m: AdaptableMatcher[Any]) extends Product with Serializable

    Permalink
  113. trait StringMatchers extends StringBaseMatchers with StringBeHaveMatchers

    Permalink

    The StringMatchers trait provides matchers which are applicable to String objects

  114. trait ThrownExpectables extends ExpectationsCreation

    Permalink
  115. trait ThrownExpectations extends ThrownExpectationsCreation with ThrownStandardResults with ThrownStandardMatchResults

    Permalink

    Thrown expectations will throw a FailureException if a match fails

    Thrown expectations will throw a FailureException if a match fails

    This trait can be extended to be used in another framework like ScalaTest:

    trait ScalaTestExpectations extends ThrownExpectations { override protected def checkFailure[T](m: =>MatchResult[T]) = { m match { case f @ MatchFailure(ok, ko, _, _, _) => throw new TestFailedException(f.message, f.exception, 0) case _ => () } m } }

  116. trait ThrownExpectationsCreation extends ThrownExpectables

    Permalink

    Lightweight ThrownExpectations trait with less implicit methods

  117. trait ThrownMessages extends AnyRef

    Permalink

    This trait can be used to integrate failures and skip messages into specs2

  118. trait ThrownStandardMatchResults extends StandardMatchResults with ExpectationsCreation

    Permalink
  119. trait ThrownStandardResults extends StandardResults with ExpectationsCreation

    Permalink
  120. trait TraversableMatchers extends TraversableBaseMatchers with TraversableBeHaveMatchers with LazyParameters with TraversableBaseMatchersLowImplicits with ImplicitParameters with NumberOfTimes

    Permalink

    Matchers for traversables

  121. case class TryFailureCheckedMatcher[T](check: ValueCheck[Throwable]) extends OptionLikeCheckedMatcher[Try, T, Throwable] with Product with Serializable

    Permalink
  122. case class TryFailureMatcher[T]() extends OptionLikeMatcher[Try, T, Throwable] with Product with Serializable

    Permalink
  123. trait TryMatchers extends TryBaseMatchers with TryBeHaveMatchers

    Permalink

    Matchers for util.Try instances

  124. case class TrySuccessCheckedMatcher[T](check: ValueCheck[T]) extends OptionLikeCheckedMatcher[Try, T, T] with Product with Serializable

    Permalink
  125. case class TrySuccessMatcher[T]() extends OptionLikeMatcher[Try, T, T] with Product with Serializable

    Permalink
  126. trait TypedEqual extends AnyRef

    Permalink

    This trait adds some implicits to create expectations with the === sign

  127. trait ValueCheck[T] extends AnyRef

    Permalink

    Common interface for checks of a value of type T:

    Common interface for checks of a value of type T:

    • a expected single value of type T
    • a Matcher[T]
    • a function returning a type R having an AsResult instance
  128. trait ValueChecks extends ValueChecksBase

    Permalink

    implicit conversions used to create ValueChecks

  129. trait ValueChecksBase extends ValueChecksLowImplicits

    Permalink
  130. trait ValueChecksLowImplicits extends AnyRef

    Permalink

Value Members

  1. object AnyMatchers extends AnyMatchers

    Permalink
  2. object BeMatching

    Permalink
  3. object DataTable extends Serializable

    Permalink
  4. object DataTableRow extends Serializable

    Permalink
  5. object DataTablesGenerator

    Permalink
  6. object EitherMatchers extends EitherMatchers

    Permalink
  7. object EventuallyMatchers extends EventuallyMatchers

    Permalink
  8. object ExceptionMatchers extends ExceptionMatchers

    Permalink
  9. object Expectable

    Permalink

    Factory methods for creating Expectables

  10. object Expectations extends Expectations

    Permalink
  11. object ExpectationsDescription extends ExpectationsDescription

    Permalink
  12. object FutureMatchers extends FutureMatchers

    Permalink
  13. object MapMatchers extends MapMatchers

    Permalink
  14. object MatchFailure extends Serializable

    Permalink
  15. object MatchFailureException extends Serializable

    Permalink
  16. object MatchPendingException extends Serializable

    Permalink
  17. object MatchResult

    Permalink

    Utility functions for MatchResult.

    Utility functions for MatchResult.

    A MatchResult is a Functor where the fmap function acts on the embedded Expectable value (which itself is a Functor)

  18. object MatchResultCombinators extends MatchResultCombinators

    Permalink
  19. object MatchResultImplicits extends MatchResultImplicits

    Permalink
  20. object MatchResultLogicalCombinators extends MatchResultLogicalCombinators

    Permalink
  21. object MatchSkipException extends Serializable

    Permalink
  22. object MatchSuccess extends Serializable

    Permalink
  23. object Matcher

    Permalink
  24. object MatcherZipOperators extends MatcherZipOperators

    Permalink
  25. object Matchers extends Matchers

    Permalink
  26. object MatchersCreation extends MatchersCreation

    Permalink
  27. object MatchersImplicits extends MatchersImplicits

    Permalink
  28. object MustExpectable

    Permalink
  29. object MustExpectations extends MustExpectations

    Permalink
  30. object MustMatchers extends MustMatchers with NoMatchResultStackTrace

    Permalink
  31. object MustThrownExpectations extends MustThrownExpectations

    Permalink
  32. object MustThrownMatchers extends MustThrownMatchers with NoMatchResultStackTrace

    Permalink
  33. object NumericMatchers extends NumericMatchers

    Permalink
  34. object OperationMatchers extends OperationMatchers

    Permalink
  35. object OptionMatchers extends OptionMatchers

    Permalink
  36. object ResultImplicits extends ResultImplicits

    Permalink
  37. object ResultMatchers extends ResultMatchers

    Permalink
  38. object ReturnsSyntax extends ReturnsSyntax with Expectations

    Permalink
  39. object Scope

    Permalink
  40. object SequenceMatchersCreation extends SequenceMatchersCreation

    Permalink
  41. object ShouldExpectable

    Permalink
  42. object ShouldExpectations extends ShouldExpectations

    Permalink
  43. object ShouldMatchers extends ShouldMatchers with NoMatchResultStackTrace

    Permalink
  44. object ShouldThrownExpectations extends ShouldThrownExpectations

    Permalink
  45. object ShouldThrownMatchers extends ShouldThrownMatchers with NoMatchResultStackTrace

    Permalink
  46. object StandardMatchResults extends StandardMatchResults

    Permalink
  47. object StringMatchers extends StringMatchers

    Permalink
  48. object ThrownExpectations extends ThrownExpectations

    Permalink
  49. object TraversableMatchers extends TraversableMatchers

    Permalink
  50. object TryMatchers extends TryMatchers

    Permalink
  51. object TypedEqual extends TypedEqual with ExpectationsCreation

    Permalink
  52. object ValueCheck

    Permalink
  53. object ValueChecks extends ValueChecks

    Permalink
  54. def checkFailure[T](m: MatchResult[T]): MatchResult[T]

    Permalink

    this method can be overridden to throw exceptions when checking the match result

    this method can be overridden to throw exceptions when checking the match result

    Attributes
    protected
    Definition Classes
    ExpectationsCreation
  55. def checkMatchResultFailure[T](m: MatchResult[T]): MatchResult[T]

    Permalink

    this method can be overridden to throw exceptions when checking the match result

    this method can be overridden to throw exceptions when checking the match result

    Attributes
    protected
    Definition Classes
    ExpectationsCreation
  56. def checkResultFailure(r: ⇒ Result): Result

    Permalink

    this method can be overridden to throw exceptions when checking the result

    this method can be overridden to throw exceptions when checking the result

    Attributes
    protected
    Definition Classes
    ExpectationsCreation
  57. def createExpectable[T](t: ⇒ T, alias: Option[(String) ⇒ String]): Expectable[T]

    Permalink

    returns

    an Expectable with a description function

    Definition Classes
    ExpectationsCreation
  58. def createExpectable[T](t: ⇒ T, alias: (String) ⇒ String): Expectable[T]

    Permalink

    returns

    an Expectable with a description function

    Definition Classes
    ExpectationsCreation
  59. def createExpectable[T](t: ⇒ T, alias: ⇒ String): Expectable[T]

    Permalink

    returns

    an Expectable with a description

    Definition Classes
    ExpectationsCreation
  60. def createExpectable[T](t: ⇒ T): Expectable[T]

    Permalink

    returns

    an Expectable

    Definition Classes
    ExpectationsCreation
  61. def createExpectableWithShowAs[T](t: ⇒ T, showAs: ⇒ String): Expectable[T]

    Permalink

    returns

    an Expectable with a function to show the element T

    Definition Classes
    ExpectationsCreation
  62. package describe

    Permalink
  63. def mapMatchResult[T](m: MatchResult[T]): MatchResult[T]

    Permalink

    this method can be overridden to intercept a MatchResult and change its message before it is thrown

    this method can be overridden to intercept a MatchResult and change its message before it is thrown

    Attributes
    protected
    Definition Classes
    ExpectationsCreation
  64. def sandboxMatchResult[T](mr: ⇒ MatchResult[T]): MatchResult[T]

    Permalink

    returns

    the match result without any side-effects

    Attributes
    protected
    Definition Classes
    ExpectationsCreation
  65. def setStacktrace[T](m: MatchResult[T]): MatchResult[T]

    Permalink

    this method can be overridden to avoid filling-in a stacktrace indicating the location of the result

    this method can be overridden to avoid filling-in a stacktrace indicating the location of the result

    Attributes
    protected
    Definition Classes
    MatchResultStackTrace

Inherited from ReturnsSyntax

Inherited from ExpectationsCreation

Inherited from MatchResultStackTrace

Inherited from AnyRef

Inherited from Any

Ungrouped