matcher

Type Members

1. trait AbstractContainMatchResult[T] extends MatchResult[GenTraversableOnce[T]]

2. abstract class AbstractContainMatcher[T] extends Matcher[GenTraversableOnce[T]]

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

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

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

   This matcher always matches any value of type T

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

6. class AndNotMatch[T] extends MatchResult[T]

7. trait AnyBeHaveMatchers extends AnyRef

   This trait allows to write expressions like

8. trait AnyMatchers extends AnyBaseMatchers with AnyBeHaveMatchers

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

9. trait ApplicableArbitraries extends AnyRef

   This trait enables some syntactic sugar when it is necessary to pass several arbitrary instances

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

11. case class BeEqualContainCheck[T](expected: Any) extends ContainCheck[T] with Product with Serializable

12. class BeEqualTo extends BeTypedEqualTo[Any]

    Equality Matcher

13. case class BeEqualTypedContainCheck[T](expected: T) extends ContainCheck[T] with Product with Serializable

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

15. class BeLessThanOrEqualTo[T] extends Matcher[T]

16. class BeMatching extends Matcher[String]

    Attributes

    protected[org.specs2]

17. class BeMatchingPattern extends BeMatching

    Attributes

    protected[org.specs2]

18. class BeMatchingRegex extends BeMatching

19. class BeNull[T] extends Matcher[T]

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

21. class BeTheSameAs[T <: AnyRef] extends Matcher[T]

22. class BeTrueMatcher extends Matcher[Boolean]

    Matcher for a boolean value which must be true

23. class BeTypedEqualTo[T] extends AdaptableMatcher[T]

    Typed equality Matcher

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

25. trait CanBeEqual extends AnyRef

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

26. class ContainAnyOfMatcher[T] extends AbstractContainMatcher[T]

27. trait ContainCheck[T] extends AnyRef

28. trait ContainChecks extends AnyRef

29. class ContainExactlyOnceMatcher[T] extends AbstractContainMatcher[T]

30. class ContainInOrderMatchResult[T] extends AbstractContainMatchResult[T]

31. class ContainInOrderMatcher[T] extends AbstractContainMatcher[T]

32. class ContainMatchResult[T] extends AbstractContainMatchResult[T]

33. class ContainMatcher[T] extends AbstractContainMatcher[T]

34. class ContainNotMatchResult[T] extends ContainMatchResult[T]

35. class ContainOnlyInOrderMatchResult[T] extends AbstractContainMatchResult[T]

36. class ContainOnlyMatchResult[T] extends AbstractContainMatchResult[T]

37. class ContainOnlyMatcher[T] extends AbstractContainMatcher[T]

38. case class ContainWithResult[T](check: ContainCheck[T], timesMin: Option[Times] = ..., timesMax: Option[Times] = scala.None, checkAll: Boolean = true) extends Matcher[GenTraversableOnce[T]] with Product with Serializable

39. case class ContainWithResultSeq[T](checks: Seq[ContainCheck[T]], containsAtLeast: Boolean = true, containsAtMost: Boolean = false, checkOrder: Boolean = false) extends Matcher[GenTraversableOnce[T]] with Product with Serializable

40. trait ContentMatchers extends ContentBaseMatchers with ContentBeHaveMatchers

    The ContentMatchers trait provides matchers to make comparisons between files, sequences,.

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

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

43. trait DataTables extends Expectations

    This trait provides implicit definitions and types to create DataTables.

44. case class Delta[S](n: S, delta: S) extends Product with Serializable

    class representing a numeric range

45. trait DependencyBeHaveMatchers extends AnyRef

46. trait DependencyMatchers extends DependencyBaseMatchers with DependencyBeHaveMatchers

    The dependency matchers trait provides a way to specify the dependencies that should be verified in your project and then to check that there's no unwanted dependency in the code.

47. trait EitherMatchers extends EitherBaseMatchers with EitherBeHaveMatchers

    Matchers for the Either datatype

48. class EqualIgnoringSpaceMatcher extends Matcher[Seq[Node]] with XmlMatcherKoMessage

    Matcher for equalIgnoreSpace comparison, ignoring the nodes order

49. class EqualIgnoringSpaceMatcherOrdered extends Matcher[Seq[Node]] with XmlMatcherKoMessage

    Matcher for equalIgnoreSpace comparison, considering the node order

50. trait EventuallyMatchers extends EventuallyResults

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

51. trait ExceptionMatchers extends ExceptionBaseMatchers with ExceptionBeHaveMatchers

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

52. class Expectable[+T] extends AnyRef

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

53. trait Expectations extends CanBeEqual

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

54. trait ExpectationsDescription extends Sentences with Expectations

55. case class ExpectedParsedResult[+T](t: T) extends Product with Serializable

    This class is only used as a transient holder for the expected parsed value, to overcome overloaded method issues

56. trait FileMatchers extends FileBaseMatchers with FileBeHaveMatchers

    The FileMatchers trait provides matchers which are applicable to files

57. trait FunctionPropertyImplicits extends AnyRef

    This trait adds some syntactic sugar to transform function to properties by appending forAll

58. trait FutureMatchers extends Expectations

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

59. trait Hamcrest extends AnyRef

    This trait adds implicit conversions to be able to use [Hamcrest matchers](http://code.

60. case class HaveAllElementsLike[T, U](like: PartialFunction[T, MatchResult[U]]) extends Matcher[GenTraversableOnce[T]] with Product with Serializable

61. case class HaveOneElementLike[T, U](like: PartialFunction[T, MatchResult[U]]) extends Matcher[GenTraversableOnce[T]] with Product with Serializable

62. class HaveTheSameElementsAs[T] extends AbstractContainMatcher[T]

    This matcher checks if a traversable has the same elements as another one (that is, recursively, in any order)

63. trait JUnitExpectations extends ThrownExpectations

    This trait throws AssertionFailed errors when a match fails.

64. trait JUnitMustExpectations extends MustThrownExpectations with JUnitExpectations

    This trait can be imported to use MustMatchers in JUnit

65. trait JUnitMustMatchers extends Matchers with JUnitMustExpectations

    These traits and objects can be used in JUnit

66. trait JUnitShouldExpectations extends ShouldThrownExpectations with JUnitExpectations

    This trait can be imported to use ShouldMatchers in JUnit

67. trait JUnitShouldMatchers extends Matchers with JUnitShouldExpectations

68. trait JsonMatchers extends JsonBaseMatchers with JsonBaseBeHaveMatchers

    Matchers for Json expressions (entered as strings)

69. trait MapMatchers extends MapBaseMatchers with MapBeHaveMatchers

    Matchers for Maps

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

71. class MatchFailureException[T] extends FailureException with MatchResultException[T]

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

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

73. class MatchPendingException[T] extends PendingException with MatchResultException[T]

    this class allows to throw a pending result in an Exception

74. trait MatchResult[+T] extends ResultLike

    Result of a Match.

75. trait MatchResultException[T] extends AnyRef

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

77. class MatchSkipException[T] extends SkipException with MatchResultException[T]

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

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

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

79. trait Matcher[-T] extends AnyRef

    The Matcher trait is the base trait for any Matcher.

80. 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 LanguageFeatures

    Trait aggregating the most common specs2 matchers

81. trait MatchersImplicits extends Expectations with MatchResultCombinators with MatchResultImplicits with ExpectationsDescription

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

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

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

83. trait MustExpectations extends Expectations

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

84. trait MustMatchers extends Matchers with MustExpectations

85. trait MustThrownExpectations extends ThrownExpectations with MustExpectations

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

86. trait MustThrownMatchers extends Matchers with MustThrownExpectations

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

88. class NeutralMatcher[T] extends Matcher[T]

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

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

    This matcher never matches any value of type T

90. trait NoCanBeEqual extends CanBeEqual

    This trait can be used to suppress the CanBeEqual implicits

91. trait NoExpectationsDescription extends ExpectationsDescription

92. trait NoMustExpectations extends MustExpectations

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

93. trait NoScopedExpectations extends ScopedExpectations

94. trait NoShouldExpectations extends ShouldExpectations

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

95. trait NoThrownExpectations extends Expectations

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

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

97. class NotMatcher[T] extends Matcher[T]

    This special matcher always return a NotMatch MatchResult.

98. trait NumericMatchers extends NumericBaseMatchers with NumericBeHaveMatchers

    Matchers for Numerical values

99. trait OneExpectationPerProp extends ScalaCheckMatchers

    This trait can be mixed in a Specification to avoid counting the number of times that a property was executed as the number of expectations.

100. trait OptionMatchers extends OptionBaseMatchers with OptionBeHaveMatchers

     Matchers for Options

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

102. class OrNotMatch[T] extends MatchResult[T]

103. class OrderingMatcher[T] extends Matcher[Seq[T]]

104. case class Parameters(minTestsOk: Int = ..., minSize: Int = ..., maxDiscardRatio: Float = ..., maxSize: Int = ..., workers: Int = ..., rng: Random = ..., callback: TestCallback = ..., loader: Option[ClassLoader] = ..., verbose: Boolean = false, output: Output = io.ConsoleOutput) extends Product with Serializable

     This class is the base class for the display and set case classes.

105. trait ParserMatchers extends ParserBaseMatchers with ParserBeHaveMatchers

     Matchers for parser combinators

106. trait PartialFunctionPropertyImplicits extends AnyRef

     This trait adds some syntactic sugar to transform partial functions to properties by appending forAll

107. case class PathFunction(node: Node, function: (Node, String) ⇒ NodeSeq, attributes: List[String] = immutable.this.Nil, attributeValues: Map[String, String] = ..., exactMatch: Boolean = false, textMessage: Option[String] = scala.None, textMatcher: Matcher[String] = AlwaysMatcher.apply[String]()) extends (Seq[Node]) ⇒ Seq[Node] with XPathFunctions with Product with Serializable

     The PathFunction object encapsulate a search for a node and/or attributes or attributeValues with an XPath function If node has some children, then they are searched using equality

108. trait PathMatchers extends PathBaseMatchers with PathBeHaveMatchers

     The PathMatchers trait provides matchers which are applicable to strings representing paths

109. trait ResultMatchers extends ResultBaseMatchers with ResultBeHaveMatchers

     Matchers for Results

110. trait ResultPropertyImplicits extends AnyRef

111. trait ScalaCheckMatchers extends ConsoleOutput with ScalaCheckParameters with FunctionPropertyImplicits with ResultPropertyImplicits with ResultLogicalCombinators with ApplicableArbitraries with Expectations

     The ScalaCheckMatchers trait provides matchers which allow to assess properties multiple times with generated data.

112. trait ScalaCheckParameters extends AnyRef

     This trait provides generation parameters to use with the ScalaCheckMatchers

113. trait ScalaInterpreterMatchers extends Expectations

114. trait ScopedExpectations extends AnyRef

     This trait allows to enclose expectations throwing exceptions in a Scope trait:

115. class ShouldExpectable[T] extends Expectable[T]

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

116. trait ShouldExpectations extends Expectations

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

117. trait ShouldMatchers extends Matchers with ShouldExpectations

118. trait ShouldThrownExpectations extends ThrownExpectations with ShouldExpectations

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

119. trait ShouldThrownMatchers extends Matchers with ShouldThrownExpectations

120. class SizedMatcher[T] extends Matcher[T]

121. trait StandardMatchResults extends Expectations

     This trait can be used in conjonction with Pattern matchers:

122. trait StoredExpectations extends Expectations

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

123. trait StringMatchers extends StringBaseMatchers with StringBeHaveMatchers

     The StringMatchers trait provides matchers which are applicable to String objects

124. class TerminationMatcher[-T] extends Matcher[T]

125. trait TerminationMatchers extends TerminationBaseMatchers with TerminationNotMatchers

     This trait provides matchers to check if a block of code is terminating or not

126. trait ThrownExpectations extends Expectations with StandardResults with ScopedExpectations

     Thrown expectations will throw a FailureException if a match fails

127. trait ThrownMessages extends AnyRef

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

128. trait TraversableMatchers extends TraversableBaseMatchers with NumberOfTimes with TraversableBeHaveMatchers with DeprecatedTraversableBaseMatchers with LazyParameters

     Matchers for traversables

129. trait TryMatchers extends TryBaseMatchers with TryBeHaveMatchers

     Matchers for util.

130. trait XPathFunctions extends AnyRef

131. case class XmlMatcher(functions: Seq[PathFunction]) extends Matcher[Seq[Node]] with Product with Serializable

     The XmlMatcher class matches an xml Node, or a list of Nodes against a list of search functions, which can either search for:

132. trait XmlMatcherKoMessage extends AnyRef

133. trait XmlMatchers extends XmlBaseMatchers with XmlBeHaveMatchers

     The XmlMatchers trait provides matchers which are applicable to xml nodes