ResultOfCollectedAny

final class ResultOfCollectedAny[T](collected: Collected, xs: Iterable[T], original: Any, prettifier: Prettifier, pos: Position)

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

class Object
trait Matchable
class Any

Value members

Concrete methods

infix def must(rightMatcher: Matcher[T]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all(xs) must be (3)
       ^
infix def must[TYPECLASS1[_]](rightMatcherFactory1: MatcherFactory1[T, TYPECLASS1])(implicit typeClass1: TYPECLASS1[T]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all(xs) must equal (3)
       ^
infix def must[TYPECLASS1[_], TYPECLASS2[_]](rightMatcherFactory2: MatcherFactory2[T, TYPECLASS1, TYPECLASS2])(implicit typeClass1: TYPECLASS1[T], typeClass2: TYPECLASS2[T]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all(xs) must (equal (expected) and have length 12)
       ^
infix def must(beWord: BeWord): ResultOfBeWordForCollectedAny[T]

This method enables syntax such as the following:

This method enables syntax such as the following:

all(xs) must be theSameInstanceAs anotherObject
       ^
infix def must(notWord: NotWord): ResultOfNotWordForCollectedAny[T]

This method enables syntax such as the following:

This method enables syntax such as the following:

all(xs) must not equal (3)
       ^
infix def must(haveWord: HaveWord): ResultOfHaveWordForCollectedExtent[T]

This method enables syntax such as the following:

This method enables syntax such as the following:

all (results) must have length (3)
      ^
all (results) must have size (3)
      ^
infix def must[U](inv: TripleEqualsInvocation[U])(implicit constraint: CanEqual[T, U]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all (xs) must === (b)
        ^
infix def must(inv: TripleEqualsInvocationOnSpread[T])(implicit ev: Numeric[T]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all (xs) must === (100 +- 1)
        ^
infix def must(containWord: ContainWord): ResultOfContainWordForCollectedAny[T]

This method enables syntax such as the following:

This method enables syntax such as the following:

all (xs) must contain oneOf (1, 2, 3)
        ^
infix def must(existWord: ExistWord)(implicit existence: Existence[T]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all(xs) must exist
       ^
infix def must(notExist: ResultOfNotExist)(implicit existence: Existence[T]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all(xs) must not (exist)
       ^
infix def must(startWithWord: StartWithWord)(implicit ev: T <:< String): ResultOfStartWithWordForCollectedString

This method enables syntax such as the following:

This method enables syntax such as the following:

all(string) must startWith regex ("Hel*o")
           ^
infix def must(endWithWord: EndWithWord)(implicit ev: T <:< String): ResultOfEndWithWordForCollectedString

This method enables syntax such as the following:

This method enables syntax such as the following:

all(string) must endWith regex ("wo.ld")
           ^
infix def must(includeWord: IncludeWord)(implicit ev: T <:< String): ResultOfIncludeWordForCollectedString

This method enables syntax such as the following:

This method enables syntax such as the following:

all(string) must include regex ("wo.ld")
           ^
infix def must(fullyMatchWord: FullyMatchWord)(implicit ev: T <:< String): ResultOfFullyMatchWordForCollectedString

This method enables syntax such as the following:

This method enables syntax such as the following:

all(string) must fullyMatch regex ("""(-)?(\d+)(\.\d*)?""")
           ^
infix def mustBe(sortedWord: SortedWord)(implicit sortable: Sortable[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) mustBe sorted
       ^
infix def mustBe(readableWord: ReadableWord)(implicit readability: Readability[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) mustBe readable
       ^
infix def mustBe(writableWord: WritableWord)(implicit writability: Writability[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) mustBe writable
       ^
infix def mustBe(emptyWord: EmptyWord)(implicit emptiness: Emptiness[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) mustBe empty
       ^
infix def mustBe(definedWord: DefinedWord)(implicit definition: Definition[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) mustBe defined
       ^
infix def mustBe(aType: ResultOfATypeInvocation[_]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) mustBe a [Type]
       ^
infix def mustBe(anType: ResultOfAnTypeInvocation[_]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) mustBe an [Type]
       ^
infix def mustBe[R](right: R)(implicit caneq: CanEqual[T, R]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all (xs) mustBe 7
        ^
infix def mustBe(comparison: ResultOfLessThanComparison[T]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all(4, 5, 6) mustBe < (7)
            ^
infix def mustBe(comparison: ResultOfLessThanOrEqualToComparison[T]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all(4, 5, 6) mustBe <= (7)
            ^
infix def mustBe(comparison: ResultOfGreaterThanComparison[T]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all(8, 9, 10) mustBe > (7)
             ^
infix def mustBe(comparison: ResultOfGreaterThanOrEqualToComparison[T]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all(8, 9, 10) mustBe >= (7)
             ^
infix def mustBe(beMatcher: BeMatcher[T]): Assertion

This method enables the following syntax, where odd refers to a BeMatcher[Int]:

This method enables the following syntax, where odd refers to a BeMatcher[Int]:

testing
all(xs) mustBe odd
       ^
infix def mustBe(spread: Spread[T]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all(xs) mustBe 7.1 +- 0.2
       ^
infix def mustBe(resultOfSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication)(implicit toAnyRef: T <:< AnyRef): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all(xs) mustBe theSameInstanceAs (anotherObject)
       ^
infix def mustBe(o: Null)(implicit ev: T <:< AnyRef): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) mustBe null
       ^
infix def mustBe[U <: T](bePropertyMatcher: BePropertyMatcher[U])(implicit ev: T <:< AnyRef): Assertion

This method enables the following syntax, where excellentRead refers to a BePropertyMatcher[Book]:

This method enables the following syntax, where excellentRead refers to a BePropertyMatcher[Book]:

all(xs) mustBe excellentRead
       ^
infix def mustBe[U <: T](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U])(implicit ev: T <:< AnyRef): Assertion

This method enables the following syntax, where goodRead refers to a BePropertyMatcher[Book]:

This method enables the following syntax, where goodRead refers to a BePropertyMatcher[Book]:

all(xs) mustBe a (goodRead)
       ^
infix def mustBe[U <: T](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[U])(implicit ev: T <:< AnyRef): Assertion

This method enables the following syntax, where excellentRead refers to a BePropertyMatcher[Book]:

This method enables the following syntax, where excellentRead refers to a BePropertyMatcher[Book]:

all(xs) mustBe an (excellentRead)
       ^
infix def mustEqual(right: Any)(implicit equality: Equality[T]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all (xs) mustEqual 7
        ^
infix def mustEqual(spread: Spread[T]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

result mustEqual 7.1 +- 0.2
      ^doCollected
infix def mustEqual(right: Null)(implicit ev: T <:< AnyRef): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

result mustEqual null
      ^
infix def mustNot[U <: T](rightMatcherX1: Matcher[U]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all(xs) mustNot (be (3))
       ^
infix def mustNot[TYPECLASS1[_]](rightMatcherFactory1: MatcherFactory1[T, TYPECLASS1])(implicit typeClass1: TYPECLASS1[T]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all(xs) mustNot (equal (3))
       ^
infix def mustNot(beWord: BeWord): ResultOfBeWordForCollectedAny[T]

This method enables the following syntax:

This method enables the following syntax:

all(xs) mustNot be theSameInstanceAs anotherInstance
       ^
infix def mustNot(containWord: ContainWord): ResultOfContainWordForCollectedAny[T]

This method enables syntax such as the following:

This method enables syntax such as the following:

all (xs) mustNot contain (oneOf (1, 2, 3))
        ^
infix def mustNot(existWord: ExistWord)(implicit existence: Existence[T]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all(xs) mustNot exist
       ^
infix def mustNot(fullyMatchWord: FullyMatchWord)(implicit ev: T <:< String): ResultOfFullyMatchWordForCollectedString

This method enables syntax such as the following:

This method enables syntax such as the following:

all(string) mustNot fullyMatch regex ("""(-)?(\d+)(\.\d*)?""")
           ^
infix def mustNot(startWithWord: StartWithWord)(implicit ev: T <:< String): ResultOfStartWithWordForCollectedString

This method enables syntax such as the following:

This method enables syntax such as the following:

all(string) mustNot startWith regex ("Hel*o")
           ^
infix def mustNot(endWithWord: EndWithWord)(implicit ev: T <:< String): ResultOfEndWithWordForCollectedString

This method enables syntax such as the following:

This method enables syntax such as the following:

all(string) mustNot endWith regex ("wo.ld")
           ^
infix def mustNot(includeWord: IncludeWord)(implicit ev: T <:< String): ResultOfIncludeWordForCollectedString

This method enables syntax such as the following:

This method enables syntax such as the following:

all(string) mustNot include regex ("wo.ld")
           ^
override def toString: String

Overrides to return pretty toString.

Overrides to return pretty toString.

Returns:

"ResultOfCollectedAny([collected], [xs])"

Definition Classes
Any