specs2-core
API
Generated with
specs2-core/org.specs2/org.specs2.specification/SpecificationFeatures

SpecificationFeatures

org.specs2.specification.SpecificationFeatures
trait SpecificationFeatures extends MustMatchers, ShouldMatchers, Expectations, StandardResults, ExpectedResults, MatcherImplicits, ResultLogicalCombinators, PendingUntilFixed, Debug, ImplicitExecutionContexts

List of all the features which are being included the default Specification class:

  • matchers (with the expectations dsl and the most common matchers)
  • standard results
  • pending until fixed
  • implicit parameters to overload some method calls
  • .pp calls to print out some expressions

Attributes

Graph
Supertypes
trait ImplicitExecutionContexts
trait ImplicitExecutionContextFromExecutionEnv
trait Debug
trait ResultLogicalCombinators
trait Results
trait MatcherImplicits
trait ExpectedResults
trait StandardResults
trait Expectations
trait ExpectationsDescription
trait ShouldMatchers
trait ShouldExpectations
trait MustMatchers
trait MustExpectations
trait TypedEqual
trait Matchers
trait FutureMatchers
trait EventuallyMatchers
trait EventuallyResults
trait TryMatchers
trait EitherMatchers
trait OptionMatchers
trait ValueChecks
trait ValueChecksBase
trait NumericMatchers
trait ExceptionMatchers
trait ExpectationsCreation
trait ResultChecks
trait MatchResultStackTrace
trait StringMatchers
trait MapMatchers
trait TraversableMatchers
trait NumberOfTimes
trait ValueChecksLowImplicits
trait TraversableBaseMatchers
trait AnyMatchers
class Object
trait Matchable
class Any
Show all
Known subtypes
Show all

Members list

Type members

Inherited classlikes

class ExceptionMatcher[E <: Throwable](klass: Class[_], pf: Option[PartialFunction[E, Result]]) extends Matcher[Any]

An exception matcher checks if an expression throws some specified exceptions:

An exception matcher checks if an expression throws some specified exceptions:

  • by checking the type of exception
    • if no exception is thrown it returns a success
    • if an exception is thrown with with a subtype of java.lang.Error and we expect an Exception then it is re-thrown
    • if an exception is thrown with a different type it returns a failure
  • by checking the exception message
  • by checking a condition on the exception

Attributes

Inherited from:
ExceptionMatchers
Supertypes
trait Matcher[Any]
class Object
trait Matchable
class Any
class FindMatcher(t: => String) extends Matcher[String]

Matcher to find if the regexp a is found inside b. This matcher can be specialized to a FindMatcherWithGroups which will also check the found groups

Matcher to find if the regexp a is found inside b. This matcher can be specialized to a FindMatcherWithGroups which will also check the found groups

Attributes

Inherited from:
StringMatchers
Supertypes
trait Matcher[String]
class Object
trait Matchable
class Any
Known subtypes
class FindMatcherPattern(p: Pattern) extends FindMatcher

Matcher to find if the pattern p is found inside b.

Matcher to find if the pattern p is found inside b.

Attributes

Inherited from:
StringMatchers
Supertypes
class FindMatcher
trait Matcher[String]
class Object
trait Matchable
class Any
Known subtypes
class FindMatcherPatternWithGroups(p: Pattern, groups: String*) extends FindMatcherWithGroups

Matcher to find if the pattern p is found inside b.

Matcher to find if the pattern p is found inside b.

Attributes

Inherited from:
StringMatchers
Supertypes
trait Matcher[String]
class Object
trait Matchable
class Any
class FindMatcherRegex(r: Regex) extends FindMatcherPattern

Matcher to find if the Regex r is found inside b.

Matcher to find if the Regex r is found inside b.

Attributes

Inherited from:
StringMatchers
Supertypes
class FindMatcher
trait Matcher[String]
class Object
trait Matchable
class Any
Show all
class FindMatcherWithGroups(t: => String, groups: String*) extends Matcher[String]

Matcher to find if the regexp a is found inside b. This matcher checks if the found groups are really the ones expected

Matcher to find if the regexp a is found inside b. This matcher checks if the found groups are really the ones expected

Attributes

Inherited from:
StringMatchers
Supertypes
trait Matcher[String]
class Object
trait Matchable
class Any
Known subtypes
class ResultLogicalCombinator(res: => Result)

Attributes

Inherited from:
ResultLogicalCombinators
Supertypes
class Object
trait Matchable
class Any
implicit class expectShould[T](tm: => T)(using not: NotGiven[NoShouldExpectations])

Attributes

Inherited from:
ShouldExpectations
Supertypes
class Object
trait Matchable
class Any
implicit class expectedShould[T](tm: Expectable[T])(using not: NotGiven[NoShouldExpectations])

Attributes

Inherited from:
ShouldExpectations
Supertypes
class Object
trait Matchable
class Any
object given_Conversion_Boolean_Result extends Conversion[Boolean, Result]

implicit definition to accept any boolean value as a Result This avoids writing b must beTrue

implicit definition to accept any boolean value as a Result This avoids writing b must beTrue

Attributes

Inherited from:
Results
Supertypes
class Conversion[Boolean, Result]
trait Boolean => Result
class Object
trait Matchable
class Any

Value members

Inherited methods

def !=/(s: String): Matcher[String]

matches if a.toLowerCase.trim != b.toLowerCase.trim

matches if a.toLowerCase.trim != b.toLowerCase.trim

Attributes

Inherited from:
StringMatchers
def !==[T](t: => T)(using evidence$4: Diffable[T]): Matcher[T]

matches if a != b

matches if a != b

Attributes

Inherited from:
AnyMatchers
def <[S](n: S)(using evidence$19: Ordering[S]): BeLessThan[S]

alias for beLessThan

alias for beLessThan

Attributes

Inherited from:
NumericMatchers
def <=[S](n: S)(using evidence$15: Ordering[S]): BeLessThanOrEqualTo[S]

alias for beLessThanOrEqualTo

alias for beLessThanOrEqualTo

Attributes

Inherited from:
NumericMatchers
def ==/(s: String): Matcher[String]

matches if a.toLowerCase.trim = b.toLowerCase.trim

matches if a.toLowerCase.trim = b.toLowerCase.trim

Attributes

Inherited from:
StringMatchers
def ===[T](t: => T)(using evidence$3: Diffable[T]): EqualityMatcher[T]

matches if a == b

matches if a == b

Attributes

Inherited from:
AnyMatchers
def ==~[T, S](s: => S)(using evidence$8: Diffable[T], convert: Conversion[S, T]): Matcher[T]

matches if a == b after an implicit conversion

matches if a == b after an implicit conversion

Attributes

Inherited from:
AnyMatchers
def =~[T](t: T)(using evidence$5: MatchingExpression[T]): Matcher[String]

alias for beMatching but matching just a fragment of the string

alias for beMatching but matching just a fragment of the string

Attributes

Inherited from:
StringMatchers
def >[S](n: S)(using evidence$27: Ordering[S]): BeGreaterThan[S]

alias for beGreaterThan

alias for beGreaterThan

Attributes

Inherited from:
NumericMatchers
def >=[S](n: S)(using evidence$23: Ordering[S]): Matcher[S]

alias for beGreaterThanOrEqualTo

alias for beGreaterThanOrEqualTo

Attributes

Inherited from:
NumericMatchers
def aFailedTry[T](t: Throwable): TryFailureCheckedMatcher[T]

Attributes

Inherited from:
TryMatchers
def aFailedTry[T](check: ValueCheck[Throwable]): TryFailureCheckedMatcher[T]

Attributes

Inherited from:
TryMatchers
def aFailedTry[T]: TryFailureMatcher[T]

Attributes

Inherited from:
TryMatchers
def aSuccessfulTry[T](t: T)(using evidence$2: Diffable[T]): TrySuccessCheckedMatcher[T]

Attributes

Inherited from:
TryMatchers
def aSuccessfulTry[T](check: ValueCheck[T]): TrySuccessCheckedMatcher[T]

Attributes

Inherited from:
TryMatchers
def aSuccessfulTry[T]: TrySuccessMatcher[T]

Attributes

Inherited from:
TryMatchers
def allOf[T](checks: ValueCheck[T]*): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def anError(message: String): Error

Attributes

Inherited from:
StandardResults
def anError: Error

Attributes

Inherited from:
StandardResults
def anyOf[T](t: T*): Matcher[T]

alias for beOneOf, which can be used with contain matchers

alias for beOneOf, which can be used with contain matchers

Attributes

Inherited from:
AnyMatchers
def asNoneAs[T](other: => Option[T]): Matcher[Option[T]]

Attributes

Inherited from:
OptionMatchers
def atLeast[T](checks: ValueCheck[T]*): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def atLeastOnceWhen[T, R](values: Iterable[T])(f: PartialFunction[T, R])(using evidence$15: AsResult[R]): Result

verify the function f for at least one value, where the PartialFunction is defined

verify the function f for at least one value, where the PartialFunction is defined

Attributes

Inherited from:
MatcherImplicits
def atMost[T](checks: ValueCheck[T]*): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def atMostOnceWhen[T, R](values: Iterable[T])(f: PartialFunction[T, R])(using evidence$16: AsResult[R]): Result

verify the function f for at least one value, where the PartialFunction is defined

verify the function f for at least one value, where the PartialFunction is defined

Attributes

Inherited from:
MatcherImplicits
def await[T](m: Matcher[T])(retries: Int, timeout: FiniteDuration)(using ee: ExecutionEnv): Matcher[Future[T]]

Attributes

Inherited from:
FutureMatchers
def await[T](m: Matcher[T])(using ee: ExecutionEnv, nothing: Int): Matcher[Future[T]]

Attributes

Inherited from:
FutureMatchers
def awaitFor[T](m: Matcher[T])(timeout: FiniteDuration)(using ee: ExecutionEnv): Matcher[Future[T]]

Attributes

Inherited from:
FutureMatchers
def be[T <: AnyRef](t: => T): BeTheSameAs[T]

alias for beTheSameAs

alias for beTheSameAs

Attributes

Inherited from:
AnyMatchers
def beAFailedTry[T](check: ValueCheck[Throwable]): TryFailureCheckedMatcher[T]

Attributes

Inherited from:
TryMatchers
def beAFailedTry[T]: TryFailureMatcher[T]

Attributes

Inherited from:
TryMatchers
def beASuccessfulTry[T](check: ValueCheck[T]): TrySuccessCheckedMatcher[T]

Attributes

Inherited from:
TryMatchers
def beASuccessfulTry[T]: TrySuccessMatcher[T]

Attributes

Inherited from:
TryMatchers
def beAnInstanceOf[T](using evidence$14: ClassTag[T]): Matcher[AnyRef]

Attributes

Inherited from:
AnyMatchers
def beAnyOf[T](t: T*): Matcher[T]

alias for beOneOf

alias for beOneOf

Attributes

Inherited from:
AnyMatchers
def beAsNoneAs[T](other: => Option[T]): Matcher[Option[T]]

Attributes

Inherited from:
OptionMatchers
def beAsNullAs[T](a: => T): Matcher[T]

matches if a is null when v is null and a is not null when v is not null

matches if a is null when v is null and a is not null when v is not null

Attributes

Inherited from:
AnyMatchers
def beAssignableFrom[T](using evidence$13: ClassTag[T]): Matcher[Class[_]]

matches if v.isAssignableFrom(c)

matches if v.isAssignableFrom(c)

Attributes

Inherited from:
AnyMatchers
def beBetween[T](t1: T, t2: T)(using evidence$40: Ordering[T]): BetweenMatcher[T]

matches if a value is between 2 others according to an Ordering

matches if a value is between 2 others according to an Ordering

Attributes

Inherited from:
NumericMatchers
def beCloseTo[S](target: SignificantTarget[S])(using evidence$37: Numeric[S]): Matcher[S]

Attributes

Inherited from:
NumericMatchers
def beCloseTo[S](target: S, figures: SignificantFigures)(using evidence$36: Numeric[S]): Matcher[S]

matches if target - actual < 10 pow (log actual - significantDigits)

matches if target - actual < 10 pow (log actual - significantDigits)

Attributes

Inherited from:
NumericMatchers
def beCloseTo[S](delta: PlusOrMinus[S])(using evidence$30: Numeric[S]): Matcher[S]

matches if actual = n +/- delta

matches if actual = n +/- delta

Attributes

Inherited from:
NumericMatchers
def beCloseTo[S](n: S, delta: S)(using evidence$28: Numeric[S]): Matcher[S]

matches if actual = n +/- delta

matches if actual = n +/- delta

Attributes

Inherited from:
NumericMatchers
def beDefinedAt[K](values: K*): Matcher[PartialFunction[K, Any]]

matches if the partial function is defined at those values

matches if the partial function is defined at those values

Attributes

Inherited from:
MapMatchers
def beDefinedBy[K, V](values: (K, V)*): Matcher[PartialFunction[K, V]]

matches if the partial function is defined at those values and return expected values

matches if the partial function is defined at those values and return expected values

Attributes

Inherited from:
MapMatchers
def beEmpty[T](using evidence$9: IsEmpty[T]): Matcher[T]

matches if a.isEmpty

matches if a.isEmpty

Attributes

Inherited from:
AnyMatchers
def beEqualTo[T](t: => T)(using evidence$5: Diffable[T]): EqualityMatcher[T]

matches if a == b

matches if a == b

Attributes

Inherited from:
AnyMatchers
def beException[T](message: String)(using evidence$1: ClassTag[T]): Matcher[Throwable]

check if a Throwable has a specific class and error message The message must be a regular expression, for example (new IllegalArgumentException("incorrect arguments"): Throwable) must beExceptionIllegalArgumentException

check if a Throwable has a specific class and error message The message must be a regular expression, for example (new IllegalArgumentException("incorrect arguments"): Throwable) must beExceptionIllegalArgumentException

Attributes

Inherited from:
ExceptionMatchers
def beFailedTry[T](check: ValueCheck[Throwable]): TryFailureCheckedMatcher[T]

Attributes

Inherited from:
TryMatchers
def beFailedTry[T]: TryFailureMatcher[T]

Attributes

Inherited from:
TryMatchers
def beFalse: Matcher[Boolean]

matches if a == false

matches if a == false

Attributes

Inherited from:
AnyMatchers
def beGreaterThan[S](n: S)(using evidence$24: Ordering[S]): BeGreaterThan[S]

matches if actual > n

matches if actual > n

Attributes

Inherited from:
NumericMatchers
def beGreaterThanOrEqualTo[S](n: S)(using evidence$20: Ordering[S]): Matcher[S]

matches if actual >= n

matches if actual >= n

Attributes

Inherited from:
NumericMatchers
def beLeft[T]: LeftMatcher[T]

Attributes

Inherited from:
EitherMatchers
def beLeft[T](t: ValueCheck[T]): LeftCheckedMatcher[T]

Attributes

Inherited from:
EitherMatchers
def beLessThan[S](n: S)(using evidence$16: Ordering[S]): BeLessThan[S]

matches if actual < n

matches if actual < n

Attributes

Inherited from:
NumericMatchers
def beLessThanOrEqualTo[S](n: S)(using evidence$12: Ordering[S]): BeLessThanOrEqualTo[S]

matches if actual <= n

matches if actual <= n

Attributes

Inherited from:
NumericMatchers
def beLike[T](pattern: PartialFunction[T, Result]): Matcher[T]

matches if the value returns a successful result when applied to a PartialFunction

matches if the value returns a successful result when applied to a PartialFunction

Attributes

Inherited from:
AnyMatchers
def beMatching[T](t: => T)(using evidence$2: MatchingExpression[T]): Matcher[String]

matches if b matches the regular expression a

matches if b matches the regular expression a

Attributes

Inherited from:
StringMatchers
def beMatchingWithPart[T](t: T)(using evidence$4: MatchingExpression[T]): Matcher[String]

alias for beMatching but matching just a fragment of the string

alias for beMatching but matching just a fragment of the string

Attributes

Inherited from:
StringMatchers
def beNone: Matcher[Option[Any]]

Attributes

Inherited from:
OptionMatchers
def beNull[T]: BeNull[T]

matches if the value is null

matches if the value is null

Attributes

Inherited from:
AnyMatchers
def beOneOf[T](t: T*): Matcher[T]

matches if t.toSeq.exists(_ == v)

matches if t.toSeq.exists(_ == v)

Attributes

Inherited from:
AnyMatchers
def beRight[T]: RightMatcher[T]

Attributes

Inherited from:
EitherMatchers
def beRight[T](t: ValueCheck[T]): RightCheckedMatcher[T]

Attributes

Inherited from:
EitherMatchers
def beSome[T]: SomeMatcher[T]

Attributes

Inherited from:
OptionMatchers
def beSome[T](check: ValueCheck[T]): SomeCheckedMatcher[T]

Attributes

Inherited from:
OptionMatchers
def beSorted[T](using evidence$14: Ordering[T]): OrderingMatcher[T]

Attributes

Returns

a matcher checking if the elements are ordered

Inherited from:
TraversableBaseMatchers
def beSuccessfulTry[T](check: ValueCheck[T]): TrySuccessCheckedMatcher[T]

Attributes

Inherited from:
TryMatchers
def beSuccessfulTry[T]: TrySuccessMatcher[T]

Attributes

Inherited from:
TryMatchers
def beTheSameAs[T <: AnyRef](t: => T): BeTheSameAs[T]

matches if a eq b

matches if a eq b

Attributes

Inherited from:
AnyMatchers
def beTrue: Matcher[Boolean]

matches if a == true

matches if a == true

Attributes

Inherited from:
AnyMatchers
def be_!=[T](t: => T)(using evidence$2: Diffable[T]): Matcher[T]

matches if a != b

matches if a != b

Attributes

Inherited from:
AnyMatchers
def be_!=/(a: String): Matcher[String]

matches if a.toLowerCase.trim != b.toLowerCase.trim

matches if a.toLowerCase.trim != b.toLowerCase.trim

Attributes

Inherited from:
StringMatchers
def be_<[S](n: S)(using evidence$18: Ordering[S]): BeLessThan[S]

alias for beLessThan

alias for beLessThan

Attributes

Inherited from:
NumericMatchers
def be_<=[S](n: S)(using evidence$14: Ordering[S]): BeLessThanOrEqualTo[S]

alias for beLessThanOrEqualTo

alias for beLessThanOrEqualTo

Attributes

Inherited from:
NumericMatchers
def be_==[T](t: => T)(using evidence$1: Diffable[T]): EqualityMatcher[T]

matches if a == b

matches if a == b

Attributes

Inherited from:
AnyMatchers
def be_==/(a: String): Matcher[String]

matches if a.toLowerCase.trim = b.toLowerCase.trim

matches if a.toLowerCase.trim = b.toLowerCase.trim

Attributes

Inherited from:
StringMatchers
def be_==~[T, S](s: => S)(using evidence$7: Diffable[T], convert: Conversion[S, T]): Matcher[T]

matches if a == b after an implicit conversion

matches if a == b after an implicit conversion

Attributes

Inherited from:
AnyMatchers
def be_>[S](n: S)(using evidence$26: Ordering[S]): BeGreaterThan[S]

alias for beGreaterThan

alias for beGreaterThan

Attributes

Inherited from:
NumericMatchers
def be_>=[S](n: S)(using evidence$22: Ordering[S]): Matcher[S]

alias for beGreaterThanOrEqualTo

alias for beGreaterThanOrEqualTo

Attributes

Inherited from:
NumericMatchers
def be_~[S](delta: PlusOrMinus[S])(using evidence$35: Numeric[S]): Matcher[S]

alias for beCloseTo

alias for beCloseTo

Attributes

Inherited from:
NumericMatchers
def be_~[S](n: S)(delta: S)(using evidence$33: Numeric[S]): Matcher[S]

alias for beCloseTo

alias for beCloseTo

Attributes

Inherited from:
NumericMatchers
def between[T](t1: T, t2: T)(using evidence$41: Ordering[T]): BetweenMatcher[T]

Attributes

Inherited from:
NumericMatchers
protected def checkResultFailure(r: => Result): Result

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

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

Attributes

Inherited from:
ResultChecks
def closeTo[S](target: SignificantTarget[S])(using evidence$39: Numeric[S]): Matcher[S]

Attributes

Inherited from:
NumericMatchers
def closeTo[S](target: S, figures: SignificantFigures)(using evidence$38: Numeric[S]): Matcher[S]

Attributes

Inherited from:
NumericMatchers
def closeTo[S](delta: PlusOrMinus[S])(using evidence$31: Numeric[S]): Matcher[S]

Attributes

Inherited from:
NumericMatchers
def closeTo[S](n: S, delta: S)(using evidence$29: Numeric[S]): Matcher[S]

Attributes

Inherited from:
NumericMatchers
def contain(t: Char): Matcher[String]

matches if (b contains a)

matches if (b contains a)

Attributes

Inherited from:
StringMatchers
def contain(t: String): Matcher[String]

matches if (b contains a)

matches if (b contains a)

Attributes

Inherited from:
StringMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T], t14: ValueCheck[T], t15: ValueCheck[T], t16: ValueCheck[T], t17: ValueCheck[T], t18: ValueCheck[T], t19: ValueCheck[T], t20: ValueCheck[T], t21: ValueCheck[T], t22: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T], t14: ValueCheck[T], t15: ValueCheck[T], t16: ValueCheck[T], t17: ValueCheck[T], t18: ValueCheck[T], t19: ValueCheck[T], t20: ValueCheck[T], t21: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T], t14: ValueCheck[T], t15: ValueCheck[T], t16: ValueCheck[T], t17: ValueCheck[T], t18: ValueCheck[T], t19: ValueCheck[T], t20: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T], t14: ValueCheck[T], t15: ValueCheck[T], t16: ValueCheck[T], t17: ValueCheck[T], t18: ValueCheck[T], t19: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T], t14: ValueCheck[T], t15: ValueCheck[T], t16: ValueCheck[T], t17: ValueCheck[T], t18: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T], t14: ValueCheck[T], t15: ValueCheck[T], t16: ValueCheck[T], t17: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T], t14: ValueCheck[T], t15: ValueCheck[T], t16: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T], t14: ValueCheck[T], t15: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T], t14: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T], t13: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T], t12: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T], t11: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T], t10: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T], t9: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T], t8: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T], t7: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T], t6: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T]): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T]): ContainWithResultSeq[T]

Additional contain methods using to avoid automatic tuple conversions

Additional contain methods using to avoid automatic tuple conversions

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](cm: ContainWithResultSeq[T]): ContainWithResultSeq[T]

COLLECTION MATCHERS

COLLECTION MATCHERS

Attributes

Inherited from:
TraversableBaseMatchers
def contain[T](check: ValueCheck[T]): ContainWithResult[T]

ELEMENTS MATCHERS

ELEMENTS MATCHERS

Attributes

Inherited from:
TraversableBaseMatchers
def containAllOf[T](seq: Seq[T])(using evidence$4: Diffable[T]): ContainWithResultSeq[T]

match if a traversable contains all the elements of seq (and maybe more)

match if a traversable contains all the elements of seq (and maybe more)

Attributes

Inherited from:
TraversableBaseMatchers
def containAnyOf[T](seq: Seq[T]): ContainWithResult[T]

match if a traversable contains one of (t1, t2)

match if a traversable contains one of (t1, t2)

Attributes

Inherited from:
TraversableBaseMatchers
def containMatch[T](s: => String): Matcher[Iterable[T]]

match if traversable contains (x matches .+t+.)

match if traversable contains (x matches .+t+.)

Attributes

Inherited from:
TraversableBaseMatchers
def containPattern[T, S](s: S)(using evidence$5: MatchingExpression[S]): Matcher[Iterable[T]]

match if traversable contains (x matches p)

match if traversable contains (x matches p)

Attributes

Inherited from:
TraversableBaseMatchers
def containTheSameElementsAs[T](seq: Seq[T], equality: (T, T) => Boolean): Matcher[Iterable[T]]

does a containAll comparison in both ways

does a containAll comparison in both ways

Attributes

Inherited from:
TraversableBaseMatchers
def createExpectable[T](t: => T, alias: String => String): Expectable[T]

Attributes

Returns

an Expectable with a description function

Inherited from:
ExpectationsCreation
def createExpectable[T](t: => T, alias: => String): Expectable[T]

Attributes

Returns

an Expectable with a description

Inherited from:
ExpectationsCreation
def createExpectable[T](t: => T): Expectable[T]

Attributes

Returns

an Expectable

Inherited from:
ExpectationsCreation
def createExpectable[T](t: => T, alias: Option[String => String]): Expectable[T]

Attributes

Returns

an Expectable with a description function

Inherited from:
ExpectationsCreation
def createExpectableWithShowAs[T](t: => T, showAs: => String): Expectable[T]

Attributes

Returns

an Expectable with a function to show the element T

Inherited from:
ExpectationsCreation
def done: Success

Attributes

Inherited from:
StandardResults
def eachOf[T](checks: ValueCheck[T]*): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def endWith(t: => String): Matcher[String]

matches if b.endsWith(a)

matches if b.endsWith(a)

Attributes

Inherited from:
StringMatchers
def equalTo[T](t: => T)(using evidence$6: Diffable[T]): EqualityMatcher[T]

matches if a == b

matches if a == b

Attributes

Inherited from:
AnyMatchers
def eventually[T](nested: => Matcher[T]): Matcher[T]

Attributes

Returns

a matcher that will retry the nested matcher 40 times

Inherited from:
EventuallyMatchers
def eventually[T](nested: => Matcher[T], retries: Int, sleep: Duration): Matcher[T]

Attributes

Returns

a matcher that will retry the nested matcher a given number of times

Inherited from:
EventuallyMatchers
def eventually[T](nested: => Matcher[T], retries: Int, sleep: Int => Duration): Matcher[T]

Value parameters

sleep

the function applied on the retry number (first is 1)

Attributes

Returns

a matcher that will retry the nested matcher a given number of times

Inherited from:
EventuallyMatchers
def eventually[T](result: => T)(using evidence$3: AsResult[T]): T

Attributes

Returns

a result that is retried at least 40 times until it's ok

Inherited from:
EventuallyResults
def eventually[T](retries: Int, sleep: Duration)(result: => T)(using evidence$2: AsResult[T]): T

Attributes

Returns

a matcher that will retry the nested matcher a given number of times

Inherited from:
EventuallyResults
def eventually[T](retries: Int, sleep: Int => Duration)(result: => T)(using evidence$1: AsResult[T]): T

Value parameters

sleep

the function applied on the retry number (first is 1)

Attributes

Returns

a matcher that will retry the nested matcher a given number of times

eventually(retries = 2, sleep = _ * 100.milliseconds) {
 aResult
}
Inherited from:
EventuallyResults
def exactly[T](checks: ValueCheck[T]*): ContainWithResultSeq[T]

Attributes

Inherited from:
TraversableBaseMatchers
def failedTry[T](t: Throwable): TryFailureCheckedMatcher[T]

Attributes

Inherited from:
TryMatchers
def failedTry[T](check: ValueCheck[Throwable]): TryFailureCheckedMatcher[T]

Attributes

Inherited from:
TryMatchers
def failedTry[T]: TryFailureMatcher[T]

Attributes

Inherited from:
TryMatchers
def failure(message: String): Failure

Attributes

Inherited from:
StandardResults
def failure: Failure

Attributes

Inherited from:
StandardResults
def find(r: Regex): FindMatcherRegex

matches if the regexp r is found inside b

matches if the regexp r is found inside b

Attributes

Inherited from:
StringMatchers
def find(p: Pattern): FindMatcherPattern

matches if the pattern p is found inside b

matches if the pattern p is found inside b

Attributes

Inherited from:
StringMatchers
def find(a: => String): FindMatcher

matches if the regexp a is found inside b

matches if the regexp a is found inside b

Attributes

Inherited from:
StringMatchers
def forall[T, R](values: Iterable[T])(f: T => R)(using evidence$11: AsResult[R]): Result

verify the function f for all the values, stopping after the first failure, where the PartialFunction is defined

verify the function f for all the values, stopping after the first failure, where the PartialFunction is defined

Attributes

Inherited from:
MatcherImplicits
def forallWhen[T, R](values: Iterable[T])(f: PartialFunction[T, R])(using evidence$12: AsResult[R]): Result

Attributes

Inherited from:
MatcherImplicits
def foreach[T, R](values: Iterable[T])(f: T => R)(using evidence$13: AsResult[R]): Result

verify the function f for all the values, and collect all failures

verify the function f for all the values, and collect all failures

Attributes

Inherited from:
MatcherImplicits
def foreachWhen[T, R](values: Iterable[T])(f: PartialFunction[T, R])(using evidence$14: AsResult[R]): Result

verify the function f for all the values, and collect all failures, where the PartialFunction is defined

verify the function f for all the values, and collect all failures, where the PartialFunction is defined

Attributes

Inherited from:
MatcherImplicits
def greaterThan[S](n: S)(using evidence$25: Ordering[S]): BeGreaterThan[S]

Attributes

Inherited from:
NumericMatchers
def greaterThanOrEqualTo[S](n: S)(using evidence$21: Ordering[S]): Matcher[S]

Attributes

Inherited from:
NumericMatchers
def haveClass[T](using evidence$10: ClassTag[T]): Matcher[AnyRef]

matches if v.getClass == c

matches if v.getClass == c

Attributes

Inherited from:
AnyMatchers
def haveInterface[T](using evidence$12: ClassTag[T]): Matcher[AnyRef]

matches if x.getClass.getInterfaces.contains(T)

matches if x.getClass.getInterfaces.contains(T)

Attributes

Inherited from:
AnyMatchers
def haveKey[K](k: K): Matcher[Iterable[(K, Any)]]

matches if map.contains(k)

matches if map.contains(k)

Attributes

Inherited from:
MapMatchers
def haveKeys[K](keys: K*): Matcher[Iterable[(K, Any)]]

matches if map.contains(k) forall key k

matches if map.contains(k) forall key k

Attributes

Inherited from:
MapMatchers
def haveLength[T](check: ValueCheck[Int])(using evidence$12: Sized[T]): SizedCheckedMatcher[T]

alias for haveSize

alias for haveSize

Attributes

Inherited from:
TraversableBaseMatchers
def haveLength[T](n: Int)(using evidence$8: Sized[T]): SizedMatcher[T]

alias for haveSize

alias for haveSize

Attributes

Inherited from:
TraversableBaseMatchers
def havePair[K, V](p: (K, V)): Matcher[Iterable[(K, V)]]

matches if map contains a pair (key, value) == (k, v)

matches if map contains a pair (key, value) == (k, v)

Attributes

Inherited from:
MapMatchers
def havePairs[K, V](pairs: (K, V)*): Matcher[Iterable[(K, V)]]

matches if map contains all the specified pairs

matches if map contains all the specified pairs

Attributes

Inherited from:
MapMatchers
def haveSize[T](check: ValueCheck[Int])(using evidence$10: Sized[T]): SizedCheckedMatcher[T]

match if there is a way to size T

match if there is a way to size T

Attributes

Inherited from:
TraversableBaseMatchers
def haveSize[T](n: Int)(using evidence$6: Sized[T]): SizedMatcher[T]

match if there is a way to size T

match if there is a way to size T

Attributes

Inherited from:
TraversableBaseMatchers
def haveSuperclass[T](using evidence$11: ClassTag[T]): Matcher[AnyRef]

matches if c.isAssignableFrom(v.getClass.getSuperclass)

matches if c.isAssignableFrom(v.getClass.getSuperclass)

Attributes

Inherited from:
AnyMatchers
def haveValue[V](v: V): Matcher[Iterable[(Any, V)]]

matches if map contains a pair (key, value) with value == v

matches if map contains a pair (key, value) with value == v

Attributes

Inherited from:
MapMatchers
def haveValues[V](values: V*): Matcher[Iterable[(Any, V)]]

matches if map contains a pair (key, value) with value == v for all value v

matches if map contains a pair (key, value) with value == v for all value v

Attributes

Inherited from:
MapMatchers
def ko(m: String): Result

Attributes

Inherited from:
ExpectedResults
def left[T]: LeftMatcher[T]

Attributes

Inherited from:
EitherMatchers
def left[T](t: ValueCheck[T]): LeftCheckedMatcher[T]

Attributes

Inherited from:
EitherMatchers
def left[T](t: T)(using evidence$2: Diffable[T]): LeftCheckedMatcher[T]

Attributes

Inherited from:
EitherMatchers
def length[T](check: ValueCheck[Int])(using evidence$13: Sized[T]): SizedCheckedMatcher[T]

alias for haveSize

alias for haveSize

Attributes

Inherited from:
TraversableBaseMatchers
def length[T](n: Int)(using evidence$9: Sized[T]): SizedMatcher[T]

alias for haveSize

alias for haveSize

Attributes

Inherited from:
TraversableBaseMatchers
def lessThan[S](n: S)(using evidence$17: Ordering[S]): BeLessThan[S]

Attributes

Inherited from:
NumericMatchers
def lessThanOrEqualTo[S](n: S)(using evidence$13: Ordering[S]): BeLessThanOrEqualTo[S]

matches if actual <= n

matches if actual <= n

Attributes

Inherited from:
NumericMatchers
protected def mapResult(r: Result): Result

this method can be overridden to intercept a Result and modify it. It is used for example to set a stacktrace providing the location of a failure

this method can be overridden to intercept a Result and modify it. It is used for example to set a stacktrace providing the location of a failure

Attributes

Inherited from:
ResultChecks
def matching[T](t: => T)(using evidence$3: MatchingExpression[T]): Matcher[String]

alias to use with contain

alias to use with contain

Attributes

Inherited from:
StringMatchers
def negate(r: Result): Result

Attributes

Inherited from:
Results
def negateWhen(condition: Boolean)(r: Result): Result

Attributes

Inherited from:
Results
def none: Matcher[Option[Any]]

Attributes

Inherited from:
OptionMatchers
def not[T](m: Matcher[T]): Matcher[T]

negate a matcher

negate a matcher

Attributes

Inherited from:
AnyMatchers
def ok(m: String): Result

Attributes

Inherited from:
ExpectedResults
def pending[R](r: => R)(using evidence$1: AsResult[R]): Pending

Attributes

Inherited from:
StandardResults
def pending(message: String): Pending

Attributes

Inherited from:
StandardResults
def pending: Pending

Attributes

Inherited from:
StandardResults
def pendingUntilFixed[T](m: String)(t: => T)(using evidence$1: AsExecution[T]): Execution

Attributes

Returns

Pending unless the result of the execution is a success

Inherited from:
PendingUntilFixed
def retry[T](m: Matcher[T])(retries: Int)(using ee: ExecutionEnv): Matcher[Future[T]]

Attributes

Inherited from:
FutureMatchers
def right[T]: RightMatcher[Nothing]

Attributes

Inherited from:
EitherMatchers
def right[T](t: ValueCheck[T]): RightCheckedMatcher[T]

Attributes

Inherited from:
EitherMatchers
def right[T](t: T)(using evidence$1: Diffable[T]): RightCheckedMatcher[T]

Attributes

Inherited from:
EitherMatchers
protected def sandboxResult(r: => Result): Result

Attributes

Returns

the result without any side-effects

Inherited from:
ResultChecks
protected def setStacktrace(m: Result): Result

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

Inherited from:
MatchResultStackTrace
def size[T](check: ValueCheck[Int])(using evidence$11: Sized[T]): SizedCheckedMatcher[T]

alias for haveSize

alias for haveSize

Attributes

Inherited from:
TraversableBaseMatchers
def size[T](n: Int)(using evidence$7: Sized[T]): SizedMatcher[T]

alias for haveSize

alias for haveSize

Attributes

Inherited from:
TraversableBaseMatchers
def skipped[R](r: => R)(using evidence$2: AsResult[R]): Skipped

Attributes

Inherited from:
StandardResults
def skipped(message: String): Skipped

Attributes

Inherited from:
StandardResults
def skipped: Skipped

Attributes

Inherited from:
StandardResults
def some[T]: SomeMatcher[T]

Attributes

Inherited from:
OptionMatchers
def some[T](check: ValueCheck[T]): SomeCheckedMatcher[T]

Attributes

Inherited from:
OptionMatchers
def some[T](t: T)(using evidence$1: Diffable[T]): SomeCheckedMatcher[T]

Attributes

Inherited from:
OptionMatchers
def sorted[T](using evidence$15: Ordering[T]): OrderingMatcher[T]

alias for beSorted

alias for beSorted

Attributes

Inherited from:
TraversableBaseMatchers
def startWith(a: String): Matcher[String]

matches if b.startsWith(a)

matches if b.startsWith(a)

Attributes

Inherited from:
StringMatchers
def success(message: String): Success

Attributes

Inherited from:
StandardResults
def success: Success

Attributes

Inherited from:
StandardResults
def successfulTry[T](t: T)(using evidence$1: Diffable[T]): TrySuccessCheckedMatcher[T]

Attributes

Inherited from:
TryMatchers
def successfulTry[T](check: ValueCheck[T]): TrySuccessCheckedMatcher[T]

Attributes

Inherited from:
TryMatchers
def theBlock(t: => Nothing): Expectable[Nothing]

Attributes

Inherited from:
ExpectationsCreation
def theValue[T](t: => T): Expectable[T]

Attributes

Inherited from:
ExpectationsCreation
def throwA[E <: Throwable](e: E)(using m: ClassTag[E]): ExceptionMatcher[E]

Attributes

Returns

a matcher checking the value of an Exception

Inherited from:
ExceptionMatchers
def throwA[E <: Throwable](message: String)(using m: ClassTag[E]): ExceptionMatcher[E]

Attributes

Returns

a matcher checking the type of an Exception and its message (as a regexp)

Inherited from:
ExceptionMatchers
def throwA[E <: Throwable](using m: ClassTag[E]): ExceptionMatcher[E]

Attributes

Returns

a matcher checking the type of an Exception

Inherited from:
ExceptionMatchers
def throwAn[E <: Throwable](e: E)(using m: ClassTag[E]): ExceptionMatcher[E]

alias for throwA

alias for throwA

Attributes

Inherited from:
ExceptionMatchers
def throwAn[E <: Throwable](message: String)(using m: ClassTag[E]): ExceptionMatcher[E]

alias for throwA

alias for throwA

Attributes

Inherited from:
ExceptionMatchers
def throwAn[E <: Throwable](using m: ClassTag[E]): ExceptionMatcher[E]

alias for throwA

alias for throwA

Attributes

Inherited from:
ExceptionMatchers
def toResult(b: Boolean): Result

Attributes

Inherited from:
Results
def todo: Pending

Attributes

Inherited from:
StandardResults
def valueIsTypedValueCheck[T](expected: T)(using di: Diffable[T]): BeEqualTypedValueCheck[T]

an expected value can be used to check another value

an expected value can be used to check another value

Attributes

Inherited from:
ValueChecksBase
def wontdo: Success

Attributes

Inherited from:
StandardResults
def ~[S](delta: PlusOrMinus[S])(using evidence$34: Numeric[S]): Matcher[S]

alias for beCloseTo

alias for beCloseTo

Attributes

Inherited from:
NumericMatchers
def ~[S](n: S)(delta: S)(using evidence$32: Numeric[S]): Matcher[S]

alias for beCloseTo

alias for beCloseTo

Attributes

Inherited from:
NumericMatchers

Inherited fields

lazy val ko: Result

Attributes

Inherited from:
ExpectedResults
lazy val ok: Result

Attributes

Inherited from:
ExpectedResults

Givens

Inherited givens

given DebugConsoleOutput: ConsoleOutput

Attributes

Inherited from:
Debug
given downcastBeEqualTypedValueCheck[T, S >: T]: downcastBeEqualTypedValueCheck[T, S]

a check of type T can be downcasted implicitly to a check of type S >: T

a check of type T can be downcasted implicitly to a check of type S >: T

Attributes

Inherited from:
ValueChecks
given executionEnvToExecutionContext(using ee: ExecutionEnv, not: NotGiven[NoImplicitExecutionContextFromExecutionEnv]): ExecutionContext

if an implicit execution environment is in scope, it can be used as an execution context

if an implicit execution environment is in scope, it can be used as an execution context

Attributes

Inherited from:
ImplicitExecutionContextFromExecutionEnv
given functionIsValueCheck[T, R](using evidence$3: AsResult[R]): functionIsValueCheck[T, R]

a function returning an object having an AsResult instance can check a value

a function returning an object having an AsResult instance can check a value

Attributes

Inherited from:
ValueChecksLowImplicits
given given_Conversion_Boolean_Result: given_Conversion_Boolean_Result.type

implicit definition to accept any boolean value as a Result This avoids writing b must beTrue

implicit definition to accept any boolean value as a Result This avoids writing b must beTrue

Attributes

Inherited from:
Results
given given_Conversion_S_CanHaveDelta[S](using evidence$10: Numeric[S]): given_Conversion_S_CanHaveDelta[S]

implicit definition to create delta for the beCloseTo matcher

implicit definition to create delta for the beCloseTo matcher

Attributes

Inherited from:
NumericMatchers
given matcherIsValueCheck[T]: matcherIsValueCheck[T]

a Matcher[T] can check a value

a Matcher[T] can check a value

Attributes

Inherited from:
ValueChecksBase
given matchersToValueChecks[T]: matchersToValueChecks[T]

Attributes

Inherited from:
TraversableBaseMatchersLowImplicits (hidden)
given partialfunctionIsValueCheck[T, R](using evidence$2: AsResult[R]): partialfunctionIsValueCheck[T, R]

a partial function returning an object having an AsResult instance can check a value

a partial function returning an object having an AsResult instance can check a value

Attributes

Inherited from:
ValueChecks
given seqToValueChecks[T](using to: T => ValueCheck[T]): seqToValueChecks[T]

Attributes

Inherited from:
TraversableBaseMatchersLowImplicits (hidden)

Extensions

Inherited extensions

extension [T](description: String)(using not: NotGiven[NoExpectationsDescription])(using evidence$1: AsResult[T])
def ==>(result: => T): Result

Attributes

Inherited from:
ExpectationsDescription
extension [T](description: String)(using not: NotGiven[NoExpectationsDescription])(using evidence$2: AsResult[T])
def <==>(result: => T): Result

Attributes

Inherited from:
ExpectationsDescription
extension [T, S](f: T => S)
def ^^(m: Matcher[S]): Matcher[T]

this extension provides an inverted syntax to adapt matchers to make the adaptation more readable in some cases:

this extension provides an inverted syntax to adapt matchers to make the adaptation more readable in some cases:

  • def haveExtension(extension: =>String) = ((_:File).getPath) ^^ endWith(extension)

Attributes

Inherited from:
MatcherImplicits
extension (m: AdaptableMatcher[String])
def ignoreCase: AdaptableMatcher[String]

adapt the BeEqualTo matcher to provide ignoreCase and ignoreSpace matcher

adapt the BeEqualTo matcher to provide ignoreCase and ignoreSpace matcher

Attributes

Inherited from:
StringMatchers
def ignoreSpace: AdaptableMatcher[String]

adapt the BeEqualTo matcher to provide ignoreCase and ignoreSpace matcher

adapt the BeEqualTo matcher to provide ignoreCase and ignoreSpace matcher

Attributes

Inherited from:
StringMatchers
def trimmed: AdaptableMatcher[String]

adapt the BeEqualTo matcher to provide ignoreCase and ignoreSpace matcher

adapt the BeEqualTo matcher to provide ignoreCase and ignoreSpace matcher

Attributes

Inherited from:
StringMatchers
extension [T](m: Matcher[T])(using ee: ExecutionEnv)
def await(retries: Int, timeout: FiniteDuration): Matcher[Future[T]]

add an await method to any matcher Matcher[T] so that it can be transformed into a Matcher[Future[T]] making this implicit an extension method does not work out of the box

add an await method to any matcher Matcher[T] so that it can be transformed into a Matcher[Future[T]] making this implicit an extension method does not work out of the box

Attributes

Inherited from:
FutureMatchers
def await: Matcher[Future[T]]

add an await method to any matcher Matcher[T] so that it can be transformed into a Matcher[Future[T]] making this implicit an extension method does not work out of the box

add an await method to any matcher Matcher[T] so that it can be transformed into a Matcher[Future[T]] making this implicit an extension method does not work out of the box

Attributes

Inherited from:
FutureMatchers
def awaitFor(timeout: FiniteDuration): Matcher[Future[T]]

add an await method to any matcher Matcher[T] so that it can be transformed into a Matcher[Future[T]] making this implicit an extension method does not work out of the box

add an await method to any matcher Matcher[T] so that it can be transformed into a Matcher[Future[T]] making this implicit an extension method does not work out of the box

Attributes

Inherited from:
FutureMatchers
def retryAwait(retries: Int): Matcher[Future[T]]

add an await method to any matcher Matcher[T] so that it can be transformed into a Matcher[Future[T]] making this implicit an extension method does not work out of the box

add an await method to any matcher Matcher[T] so that it can be transformed into a Matcher[Future[T]] making this implicit an extension method does not work out of the box

Attributes

Inherited from:
FutureMatchers
extension (n: Int)(using not: NotGiven[NoNumberOfTimes])
def times: Times

This implicit definition allows to declare a number of times 3.times

This implicit definition allows to declare a number of times 3.times

Attributes

Inherited from:
NumberOfTimes
extension [T](t: => T)(using not: NotGiven[NoTypedEqual])(using evidence$2: Diffable[T])
def !==(other: => T): Result

! equality matcher on Expectables

! equality matcher on Expectables

Attributes

Inherited from:
TypedEqual
extension [T](t: => T)(using not: NotGiven[NoTypedEqual])(using evidence$1: Diffable[T])
def ===(other: => T): Result

equality matcher on Expectables

equality matcher on Expectables

Attributes

Inherited from:
TypedEqual
extension [T](t: => T)(using not: NotGiven[NoDebug], output: ConsoleOutput)
def pp(pre: String): T

print the object to the console with a small message before

print the object to the console with a small message before

Attributes

Inherited from:
Debug
def pp(show: T => String): T

print the object to the console with a specific function and return it

print the object to the console with a specific function and return it

Attributes

Inherited from:
Debug
def pp(condition: T => Boolean): T

print the object to the console and return it, if the condition is satisfied

print the object to the console and return it, if the condition is satisfied

Attributes

Inherited from:
Debug
def pp(condition: Boolean): T

print the object to the console and return it, if the condition is satisfied

print the object to the console and return it, if the condition is satisfied

Attributes

Inherited from:
Debug
def pp: T

print the object to the console and return it

print the object to the console and return it

Attributes

Inherited from:
Debug
extension [T](t: => T)(using not: NotGiven[NoPendingUntilFixed])(using evidence$3: AsExecution[T])
def pendingUntilFixed(m: String): Execution

Attributes

Returns

Pending unless the result is a success

Inherited from:
PendingUntilFixed
extension [T](t: => T)(using evidence$2: AsExecution[T], not: NotGiven[NoPendingUntilFixed])
def pendingUntilFixed: Execution

Attributes

Returns

Pending unless the result is a success

Inherited from:
PendingUntilFixed
extension [N](target: N)(using evidence$11: Numeric[N])
def within(significant: SignificantFigures): SignificantTarget[N]

implicit definition to create significant figures for the beCloseTo matcher

implicit definition to create significant figures for the beCloseTo matcher

Attributes

Inherited from:
NumericMatchers
extension [T](tm: => T)(using not: NotGiven[NoMustExpectations])
infix def must(m: => Matcher[T]): Result

Attributes

Inherited from:
MustExpectations
extension [T](tm: Expectable[T])(using not: NotGiven[NoMustExpectations])
infix def must(m: => Matcher[T]): Result

Attributes

Inherited from:
MustExpectations
extension (value: Int)
def significantFigure: SignificantFigures

implicit definition to create significant figures for the beCloseTo matcher

implicit definition to create significant figures for the beCloseTo matcher

Attributes

Inherited from:
NumericMatchers
def significantFigures: SignificantFigures

implicit definition to create significant figures for the beCloseTo matcher

implicit definition to create significant figures for the beCloseTo matcher

Attributes

Inherited from:
NumericMatchers
extension [T](value: => T)(using not: NotGiven[NoValueDescription])
infix def aka(alias: => String): Expectable[T]

Attributes

Returns

an expectable with an alias description

Inherited from:
ExpectationsDescription
infix def aka: Expectable[T]

Attributes

Returns

an expectable with its toString method as an alias description this is useful to preserve the original value when the matcher using it is adapting the value

Inherited from:
ExpectationsDescription
infix def as(alias: String => String): Expectable[T]

Attributes

Returns

an expectable with an alias description, after the value string

Inherited from:
ExpectationsDescription
infix def post(alias: => String): Expectable[T]

Attributes

Returns

an expectable with an alias description, after the value string

Inherited from:
ExpectationsDescription
infix def showAs(show: T => String): Expectable[T]

Attributes

Returns

an expectable with a function to show the element T

Inherited from:
ExpectationsDescription
extension [T](value: => T)(using not: NotGiven[NoValueDescription], show: T => String)
infix def showAs: Expectable[T]

Attributes

Returns

an expectable with a function to show the element T

Inherited from:
ExpectationsDescription
extension [T, R](values: Iterable[T])(using evidence$1: AsResult[R])
def atLeastOnce(f: T => R): Result

Extend collections to check all their elements

Extend collections to check all their elements

Attributes

Inherited from:
MatcherImplicits
extension [T, R](values: Iterable[T])(using evidence$5: AsResult[R])
def atMost(n: Times)(f: T => R): Result

Extend collections to check all their elements

Extend collections to check all their elements

Attributes

Inherited from:
MatcherImplicits
extension [T, R](values: Iterable[T])(using evidence$4: AsResult[R])
def atLeast(n: Int)(f: T => R): Result

Extend collections to check all their elements

Extend collections to check all their elements

Attributes

Inherited from:
MatcherImplicits
extension [T, R](values: Iterable[T])(using evidence$10: AsResult[R])
def exactly(n: Int)(f: T => R): Result

Extend collections to check all their elements

Extend collections to check all their elements

Attributes

Inherited from:
MatcherImplicits
extension [T, R](values: Iterable[T])(using evidence$2: AsResult[R])
def atMostOnce(f: T => R): Result

Extend collections to check all their elements

Extend collections to check all their elements

Attributes

Inherited from:
MatcherImplicits
extension [T, R](values: Iterable[T])(using evidence$3: AsResult[R])
def atLeast(n: Times)(f: T => R): Result

Extend collections to check all their elements

Extend collections to check all their elements

Attributes

Inherited from:
MatcherImplicits
extension [T, R](values: Iterable[T])(using evidence$8: AsResult[R])
def between(min: Int, max: Int)(f: T => R): Result

Extend collections to check all their elements

Extend collections to check all their elements

Attributes

Inherited from:
MatcherImplicits
extension [T, R](values: Iterable[T])(using evidence$7: AsResult[R])
def between(min: Times, max: Times)(f: T => R): Result

Extend collections to check all their elements

Extend collections to check all their elements

Attributes

Inherited from:
MatcherImplicits
extension [T, R](values: Iterable[T])(using evidence$9: AsResult[R])
def exactly(n: Times)(f: T => R): Result

Extend collections to check all their elements

Extend collections to check all their elements

Attributes

Inherited from:
MatcherImplicits
extension [T, R](values: Iterable[T])(using evidence$6: AsResult[R])
def atMost(n: Int)(f: T => R): Result

Extend collections to check all their elements

Extend collections to check all their elements

Attributes

Inherited from:
MatcherImplicits

Implicits

Inherited implicits

implicit def combineBoolean(b: => Boolean): ResultLogicalCombinator

Attributes

Inherited from:
ResultLogicalCombinators
implicit def combineResult(r: => Result): ResultLogicalCombinator

Attributes

Inherited from:
ResultLogicalCombinators
final implicit def expectShould[T](tm: => T)(using not: NotGiven[NoShouldExpectations]): expectShould[T]

Attributes

Inherited from:
ShouldExpectations
final implicit def expectedShould[T](tm: Expectable[T])(using not: NotGiven[NoShouldExpectations]): expectedShould[T]

Attributes

Inherited from:
ShouldExpectations
implicit def futureToResult[T](f: => Future[T])(using ee: ExecutionEnv, asResult: AsResult[T]): FutureAsResult[T]

when a Future contains a result, it can be awaited to return this result

when a Future contains a result, it can be awaited to return this result

Attributes

Inherited from:
FutureMatchers
Generated with