SpecificationFeatures

trait SpecificationFeatures extends MustMatchers with ShouldMatchers with Expectations with StandardResults with ExpectedResults with MatcherImplicits with ResultLogicalCombinators with PendingUntilFixed with ImplicitParameters with Debug with 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
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 ImplicitParameters
trait TraversableBaseMatchersLowImplicits
trait ValueChecksLowImplicits
trait TraversableBaseMatchers
trait AnyMatchers
class Object
trait Matchable
class Any

Type members

Inherited classlikes

class ExceptionClassMatcher(klass: Class[_])

Exception matcher checking the type of a thrown exception.

Exception matcher checking the type of a thrown exception.

Inherited from
ExceptionMatchers
class ExceptionMatcher[E <: Throwable](exception: E)

This matchers matches exception instances.

This matchers matches exception instances.

See also

throwA

Inherited from
ExceptionMatchers
class FindMatcher(t: => 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

Inherited from
StringMatchers
class FindMatcherPattern(p: Pattern)

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

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

Inherited from
StringMatchers
class FindMatcherPatternWithGroups(p: Pattern, groups: String*)

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

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

Inherited from
StringMatchers
class FindMatcherRegex(r: Regex)

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

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

Inherited from
StringMatchers
class FindMatcherWithGroups(t: => String, groups: 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

Inherited from
StringMatchers
Inherited from
ImplicitParameters
class ResultLogicalCombinator(res: => Result)
implicit
class expectShould[T](tm: => T)(using not: NotGiven[NoShouldExpectations])
Inherited from
ShouldExpectations
implicit
class expectedShould[T](tm: Expectable[T])(using not: NotGiven[NoShouldExpectations])
Inherited from
ShouldExpectations

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

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

matches if a != b

matches if a != b

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

alias for beLessThan

alias for beLessThan

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

alias for beLessThanOrEqualTo

alias for beLessThanOrEqualTo

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

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

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

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

matches if a == b

matches if a == b

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

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

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

alias for beGreaterThan

alias for beGreaterThan

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

alias for beGreaterThanOrEqualTo

alias for beGreaterThanOrEqualTo

Inherited from
NumericMatchers
def aFailedTry[T](t: Throwable): TryFailureCheckedMatcher[T]
Inherited from
TryMatchers
def aFailedTry[T](check: ValueCheck[Throwable]): TryFailureCheckedMatcher[T]
Inherited from
TryMatchers
def aFailedTry[T]: TryFailureMatcher[T]
Inherited from
TryMatchers
def aSuccessfulTry[T](t: T)(using evidence$2: Diffable[T]): TrySuccessCheckedMatcher[T]
Inherited from
TryMatchers
def aSuccessfulTry[T](check: ValueCheck[T]): TrySuccessCheckedMatcher[T]
Inherited from
TryMatchers
def aSuccessfulTry[T]: TrySuccessMatcher[T]
Inherited from
TryMatchers
def allOf[T](checks: ValueCheck[T]*): ContainWithResultSeq[T]
Inherited from
TraversableBaseMatchers
def anError(message: String): Error
Inherited from
StandardResults
def anError: Error
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

Inherited from
AnyMatchers
def asNoneAs[T](other: => Option[T]): Matcher[Option[T]]
Inherited from
OptionMatchers
def atLeast[T](checks: ValueCheck[T]*): ContainWithResultSeq[T]
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

Inherited from
MatcherImplicits
def atMost[T](checks: ValueCheck[T]*): ContainWithResultSeq[T]
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

Inherited from
MatcherImplicits
def await[T](m: Matcher[T])(retries: Int, timeout: FiniteDuration)(using ee: ExecutionEnv): Matcher[Future[T]]
Inherited from
FutureMatchers
def await[T](m: Matcher[T])(using ee: ExecutionEnv, nothing: Int): Matcher[Future[T]]
Inherited from
FutureMatchers
def awaitFor[T](m: Matcher[T])(timeout: FiniteDuration)(using ee: ExecutionEnv): Matcher[Future[T]]
Inherited from
FutureMatchers
def be[T <: AnyRef](t: => T): BeTheSameAs[T]

alias for beTheSameAs

alias for beTheSameAs

Inherited from
AnyMatchers
def beAFailedTry[T](check: ValueCheck[Throwable]): TryFailureCheckedMatcher[T]
Inherited from
TryMatchers
def beAFailedTry[T]: TryFailureMatcher[T]
Inherited from
TryMatchers
def beASuccessfulTry[T](check: ValueCheck[T]): TrySuccessCheckedMatcher[T]
Inherited from
TryMatchers
def beASuccessfulTry[T]: TrySuccessMatcher[T]
Inherited from
TryMatchers
def beAnInstanceOf[T](using evidence$14: ClassTag[T]): Matcher[AnyRef]
Inherited from
AnyMatchers
def beAnyOf[T](t: T*): Matcher[T]

alias for beOneOf

alias for beOneOf

Inherited from
AnyMatchers
def beAsNoneAs[T](other: => Option[T]): Matcher[Option[T]]
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

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

matches if v.isAssignableFrom(c)

matches if v.isAssignableFrom(c)

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

Inherited from
NumericMatchers
def beCloseTo[S](target: SignificantTarget[S])(using evidence$37: Numeric[S]): Matcher[S]
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)

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

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

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

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

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

matches if a.isEmpty

matches if a.isEmpty

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

matches if a == b

matches if a == b

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

Inherited from
ExceptionMatchers
def beFailedTry[T](check: ValueCheck[Throwable]): TryFailureCheckedMatcher[T]
Inherited from
TryMatchers
def beFailedTry[T]: TryFailureMatcher[T]
Inherited from
TryMatchers
def beFalse: Matcher[Boolean]

matches if a == false

matches if a == false

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

matches if actual > n

matches if actual > n

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

matches if actual >= n

matches if actual >= n

Inherited from
NumericMatchers
def beLeft[T](using p: ImplicitParam): LeftMatcher[T]
Inherited from
EitherMatchers
def beLeft[T](t: ValueCheck[T]): LeftCheckedMatcher[T]
Inherited from
EitherMatchers
def beLessThan[S](n: S)(using evidence$16: Ordering[S]): BeLessThan[S]

matches if actual < n

matches if actual < n

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

matches if actual <= n

matches if actual <= n

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

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

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

Inherited from
StringMatchers
def beNone: Matcher[Option[Any]]
Inherited from
OptionMatchers
def beNull[T]: BeNull[T]

matches if the value is null

matches if the value is null

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

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

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

Inherited from
AnyMatchers
def beRight[T](using p: ImplicitParam): RightMatcher[T]
Inherited from
EitherMatchers
def beRight[T](t: ValueCheck[T]): RightCheckedMatcher[T]
Inherited from
EitherMatchers
def beSome[T](using p: ImplicitParam): SomeMatcher[T]
Inherited from
OptionMatchers
def beSome[T](check: ValueCheck[T]): SomeCheckedMatcher[T]
Inherited from
OptionMatchers
def beSorted[T](using evidence$14: Ordering[T]): OrderingMatcher[T]
Returns

a matcher checking if the elements are ordered

Inherited from
TraversableBaseMatchers
def beSuccessfulTry[T](check: ValueCheck[T]): TrySuccessCheckedMatcher[T]
Inherited from
TryMatchers
def beSuccessfulTry[T]: TrySuccessMatcher[T]
Inherited from
TryMatchers
def beTheSameAs[T <: AnyRef](t: => T): BeTheSameAs[T]

matches if a eq b

matches if a eq b

Inherited from
AnyMatchers
def beTrue: Matcher[Boolean]

matches if a == true

matches if a == true

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

matches if a != b

matches if a != b

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

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

alias for beLessThan

alias for beLessThan

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

alias for beLessThanOrEqualTo

alias for beLessThanOrEqualTo

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

matches if a == b

matches if a == b

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

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

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

alias for beGreaterThan

alias for beGreaterThan

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

alias for beGreaterThanOrEqualTo

alias for beGreaterThanOrEqualTo

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

alias for beCloseTo

alias for beCloseTo

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

alias for beCloseTo

alias for beCloseTo

Inherited from
NumericMatchers
def between[T](t1: T, t2: T)(using evidence$41: Ordering[T]): BetweenMatcher[T]
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

Inherited from
ResultChecks
def closeTo[S](target: SignificantTarget[S])(using evidence$39: Numeric[S]): Matcher[S]
Inherited from
NumericMatchers
def closeTo[S](target: S, figures: SignificantFigures)(using evidence$38: Numeric[S]): Matcher[S]
Inherited from
NumericMatchers
def closeTo[S](delta: PlusOrMinus[S])(using evidence$31: Numeric[S]): Matcher[S]
Inherited from
NumericMatchers
def closeTo[S](n: S, delta: S)(using evidence$29: Numeric[S]): Matcher[S]
Inherited from
NumericMatchers
def contain(t: Char): Matcher[String]

matches if (b contains a)

matches if (b contains a)

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

matches if (b contains a)

matches if (b contains a)

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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
Inherited from
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T], t5: ValueCheck[T]): ContainWithResultSeq[T]
Inherited from
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T], t4: ValueCheck[T]): ContainWithResultSeq[T]
Inherited from
TraversableBaseMatchers
def contain[T](t1: ValueCheck[T], t2: ValueCheck[T], t3: ValueCheck[T]): ContainWithResultSeq[T]
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

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

COLLECTION MATCHERS

COLLECTION MATCHERS

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

ELEMENTS MATCHERS

ELEMENTS MATCHERS

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)

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)

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+.)

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)

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

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

an Expectable with a description function

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

an Expectable with a description

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

an Expectable

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

an Expectable with a description function

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

an Expectable with a function to show the element T

Inherited from
ExpectationsCreation
def done: Success
Inherited from
StandardResults
def eachOf[T](checks: ValueCheck[T]*): ContainWithResultSeq[T]
Inherited from
TraversableBaseMatchers
def endWith(t: => String): Matcher[String]

matches if b.endsWith(a)

matches if b.endsWith(a)

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

matches if a == b

matches if a == b

Inherited from
AnyMatchers
def eventually[T](nested: => Matcher[T]): Matcher[T]
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]
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 Params
sleep

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

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

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

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]
Inherited from
TraversableBaseMatchers
def failedTry[T](t: Throwable): TryFailureCheckedMatcher[T]
Inherited from
TryMatchers
def failedTry[T](check: ValueCheck[Throwable]): TryFailureCheckedMatcher[T]
Inherited from
TryMatchers
def failedTry[T]: TryFailureMatcher[T]
Inherited from
TryMatchers
def failure(message: String): Failure
Inherited from
StandardResults
def failure: Failure
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

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

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

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

Inherited from
MatcherImplicits
def forallWhen[T, R](values: Iterable[T])(f: PartialFunction[T, R])(using evidence$12: AsResult[R]): Result
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

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

Inherited from
MatcherImplicits
def greaterThan[S](n: S)(using evidence$25: Ordering[S]): BeGreaterThan[S]
Inherited from
NumericMatchers
def greaterThanOrEqualTo[S](n: S)(using evidence$21: Ordering[S]): Matcher[S]
Inherited from
NumericMatchers
def haveClass[T](using evidence$10: ClassTag[T]): Matcher[AnyRef]

matches if v.getClass == c

matches if v.getClass == c

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)

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

matches if map.contains(k)

matches if map.contains(k)

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

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

alias for haveSize

alias for haveSize

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

alias for haveSize

alias for haveSize

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)

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

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

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

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)

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

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

Inherited from
MapMatchers
def ko(m: String): Result
Inherited from
ExpectedResults
def left[T](using p: ImplicitParam): LeftCheckedMatcher[ImplicitParam]
Inherited from
EitherMatchers
def left[T](t: ValueCheck[T]): LeftCheckedMatcher[T]
Inherited from
EitherMatchers
def left[T](t: T)(using evidence$2: Diffable[T]): LeftCheckedMatcher[T]
Inherited from
EitherMatchers
def length[T](check: ValueCheck[Int])(using evidence$13: Sized[T]): SizedCheckedMatcher[T]

alias for haveSize

alias for haveSize

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

alias for haveSize

alias for haveSize

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

matches if actual <= n

matches if actual <= n

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

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

Inherited from
StringMatchers
def negate(r: Result): Result
Inherited from
Results
def negateWhen(condition: Boolean)(r: Result): Result
Inherited from
Results
def none: Matcher[Option[Any]]
Inherited from
OptionMatchers
def not[T](m: Matcher[T]): Matcher[T]

negate a matcher

negate a matcher

Inherited from
AnyMatchers
def ok(m: String): Result
Inherited from
ExpectedResults
def pending[R](r: => R)(using evidence$1: AsResult[R]): Pending
Inherited from
StandardResults
def pending(message: String): Pending
Inherited from
StandardResults
def pending: Pending
Inherited from
StandardResults
def pendingUntilFixed[T](m: String)(t: => T)(using evidence$1: AsExecution[T]): Execution
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]]
Inherited from
FutureMatchers
def right[T](using p: ImplicitParam): RightCheckedMatcher[ImplicitParam]
Inherited from
EitherMatchers
def right[T](t: ValueCheck[T]): RightCheckedMatcher[T]
Inherited from
EitherMatchers
def right[T](t: T)(using evidence$1: Diffable[T]): RightCheckedMatcher[T]
Inherited from
EitherMatchers
protected
def sandboxResult(r: => Result): Result
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

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

alias for haveSize

alias for haveSize

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

alias for haveSize

alias for haveSize

Inherited from
TraversableBaseMatchers
def skipped[R](r: => R)(using evidence$2: AsResult[R]): Skipped
Inherited from
StandardResults
def skipped(message: String): Skipped
Inherited from
StandardResults
def skipped: Skipped
Inherited from
StandardResults
def some[T]: SomeMatcher[T]
Inherited from
OptionMatchers
def some[T](check: ValueCheck[T]): SomeCheckedMatcher[T]
Inherited from
OptionMatchers
def some[T](t: T)(using evidence$1: Diffable[T]): SomeCheckedMatcher[T]
Inherited from
OptionMatchers
def sorted[T](using evidence$15: Ordering[T]): OrderingMatcher[T]

alias for beSorted

alias for beSorted

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

matches if b.startsWith(a)

matches if b.startsWith(a)

Inherited from
StringMatchers
def success(message: String): Success
Inherited from
StandardResults
def success: Success
Inherited from
StandardResults
def successfulTry[T](t: T)(using evidence$1: Diffable[T]): TrySuccessCheckedMatcher[T]
Inherited from
TryMatchers
def successfulTry[T](check: ValueCheck[T]): TrySuccessCheckedMatcher[T]
Inherited from
TryMatchers
def theBlock(t: => Nothing): Expectable[Nothing]
Inherited from
ExpectationsCreation
def theValue[T](t: => T): Expectable[T]
Inherited from
ExpectationsCreation
def throwA[E <: Throwable](e: E): ExceptionMatcher[E]
Returns

a matcher checking the value of an Exception

Inherited from
ExceptionMatchers
def throwA[E <: Throwable](message: String)(using m: ClassTag[E]): Matcher[Any]
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]): ExceptionClassMatcher
Returns

a matcher checking the type of an Exception

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

alias for throwA

alias for throwA

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

alias for throwA

alias for throwA

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

alias for throwA

alias for throwA

Inherited from
ExceptionMatchers
def toResult(b: Boolean): Result
Inherited from
Results
def todo: Pending
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

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

alias for beCloseTo

alias for beCloseTo

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

alias for beCloseTo

alias for beCloseTo

Inherited from
NumericMatchers

Inherited fields

final lazy
val DebugConsoleOutput: ConsoleOutput
Inherited from
Debug
Inherited from
ImplicitParameters
Inherited from
ImplicitParameters
Inherited from
ImplicitParameters
Inherited from
ImplicitParameters
Inherited from
ImplicitParameters
Inherited from
ImplicitParameters
Inherited from
ImplicitParameters
Inherited from
ImplicitParameters
Inherited from
ImplicitParameters
Inherited from
ImplicitParameters
Inherited from
ImplicitParameters
lazy
val ko: Result
Inherited from
ExpectedResults
lazy
val ok: Result
Inherited from
ExpectedResults

Givens

Inherited givens

given Conversion_S_CanHaveDelta[S]: Conversion[S, CanHaveDelta[S]]

implicit definition to create delta for the beCloseTo matcher

implicit definition to create delta for the beCloseTo matcher

Inherited from
NumericMatchers
given downcastBeEqualTypedValueCheck[T, S >: T]: Conversion[BeEqualTypedValueCheck[T], ValueCheck[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

Inherited from
ValueChecks

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

Inherited from
ImplicitExecutionContextFromExecutionEnv
given functionIsValueCheck[T, R]: Conversion[T => R, ValueCheck[T]]

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

Inherited from
ValueChecksLowImplicits
given given_Conversion_Boolean_Result: 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

Inherited from
Results
given matcherIsValueCheck[T]: Conversion[Matcher[T], ValueCheck[T]]

a Matcher[T] can check a value

a Matcher[T] can check a value

Inherited from
ValueChecksBase
given matchersToValueChecks[T]: Conversion[Seq[Matcher[T]], Seq[ValueCheck[T]]]
given partialfunctionIsValueCheck[T, R]: Conversion[PartialFunction[T, R], ValueCheck[T]]

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

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

Extensions

Inherited extensions

extension [T](description: String)
def <==>(using not: NotGiven[NoExpectationsDescription])(result: => T)(using evidence$2: AsResult[T]): Result
Inherited from
ExpectationsDescription
def ==>(using not: NotGiven[NoExpectationsDescription])(result: => T)(using evidence$1: AsResult[T]): Result
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)
Inherited from
MatcherImplicits
extension [T](m: Matcher[T])
def await(using ee: ExecutionEnv)(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

Inherited from
FutureMatchers
def await(using ee: ExecutionEnv): 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

Inherited from
FutureMatchers
def awaitFor(using ee: ExecutionEnv)(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

Inherited from
FutureMatchers
def retryAwait(using ee: ExecutionEnv)(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

Inherited from
FutureMatchers
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

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

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

Inherited from
StringMatchers
extension (n: Int)
def times(using not: NotGiven[NoNumberOfTimes]): 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

Inherited from
NumberOfTimes
extension [T](t: => T)
def pp(using not: NotGiven[NoDebug], output: ConsoleOutput)(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

Inherited from
Debug
def pp(using not: NotGiven[NoDebug], output: ConsoleOutput)(show: T => String)(using p: ImplicitParam): 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

Inherited from
Debug
def pp(using not: NotGiven[NoDebug], output: ConsoleOutput)(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

Inherited from
Debug
def pp(using not: NotGiven[NoDebug], output: ConsoleOutput)(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

Inherited from
Debug
def pp(using not: NotGiven[NoDebug], output: ConsoleOutput): T

print the object to the console and return it

print the object to the console and return it

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

Pending unless the result is a success

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

Pending unless the result is a success

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

! equality matcher on Expectables

! equality matcher on Expectables

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

equality matcher on Expectables

equality matcher on Expectables

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

implicit definition to create significant figures for the beCloseTo matcher

implicit definition to create significant figures for the beCloseTo matcher

Inherited from
NumericMatchers
extension [T](tm: => T)
infix
def must(using not: NotGiven[NoMustExpectations])(m: => Matcher[T]): Result
Inherited from
MustExpectations
extension [T](tm: Expectable[T])
infix
def must(using not: NotGiven[NoMustExpectations])(m: => Matcher[T]): Result
Inherited from
MustExpectations
extension [T](value: => T)
infix
def aka(using not: NotGiven[NoValueDescription])(alias: => String): Expectable[T]
Returns

an expectable with an alias description

Inherited from
ExpectationsDescription
infix
def aka(using not: NotGiven[NoValueDescription]): Expectable[T]
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(using not: NotGiven[NoValueDescription])(alias: String => String): Expectable[T]
Returns

an expectable with an alias description, after the value string

Inherited from
ExpectationsDescription
infix
def post(using not: NotGiven[NoValueDescription])(alias: => String): Expectable[T]
Returns

an expectable with an alias description, after the value string

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

an expectable with a function to show the element T

Inherited from
ExpectationsDescription
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

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

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

an expectable with a function to show the element T

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

Extend collections to check all their elements

Extend collections to check all their elements

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

Extend collections to check all their elements

Extend collections to check all their elements

Inherited from
MatcherImplicits
def atLeastOnce(f: T => R)(using evidence$1: AsResult[R]): Result

Extend collections to check all their elements

Extend collections to check all their elements

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

Extend collections to check all their elements

Extend collections to check all their elements

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

Extend collections to check all their elements

Extend collections to check all their elements

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

Extend collections to check all their elements

Extend collections to check all their elements

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

Extend collections to check all their elements

Extend collections to check all their elements

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

Extend collections to check all their elements

Extend collections to check all their elements

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

Extend collections to check all their elements

Extend collections to check all their elements

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

Extend collections to check all their elements

Extend collections to check all their elements

Inherited from
MatcherImplicits

Implicits

Inherited implicits

implicit
Inherited from
ResultLogicalCombinators
implicit
Inherited from
ResultLogicalCombinators
final implicit
def expectShould[T](tm: => T)(using not: NotGiven[NoShouldExpectations]): expectShould[T]
Inherited from
ShouldExpectations
final implicit
def expectedShould[T](tm: Expectable[T])(using not: NotGiven[NoShouldExpectations]): expectedShould[T]
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

Inherited from
FutureMatchers