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 should(rightMatcher: Matcher[T]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all(xs) should be (3)
       ^
infix def should[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) should equal (3)
       ^
infix def should[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) should (equal (expected) and have length 12)
       ^
infix def should(beWord: BeWord): ResultOfBeWordForCollectedAny[T]

This method enables syntax such as the following:

This method enables syntax such as the following:

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

This method enables syntax such as the following:

This method enables syntax such as the following:

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

This method enables syntax such as the following:

This method enables syntax such as the following:

all (results) should have length (3)
      ^
all (results) should have size (3)
      ^
infix def should[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) should === (b)
        ^
infix def should(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) should === (100 +- 1)
        ^
infix def should(containWord: ContainWord): ResultOfContainWordForCollectedAny[T]

This method enables syntax such as the following:

This method enables syntax such as the following:

all (xs) should contain oneOf (1, 2, 3)
        ^
infix def should(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) should exist
       ^
infix def should(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) should not (exist)
       ^
infix def should(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) should startWith regex ("Hel*o")
           ^
infix def should(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) should endWith regex ("wo.ld")
           ^
infix def should(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) should include regex ("wo.ld")
           ^
infix def should(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) should fullyMatch regex ("""(-)?(\d+)(\.\d*)?""")
           ^
infix def shouldBe(sortedWord: SortedWord)(implicit sortable: Sortable[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

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

This method enables the following syntax:

This method enables the following syntax:

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

This method enables the following syntax:

This method enables the following syntax:

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

This method enables the following syntax:

This method enables the following syntax:

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

This method enables the following syntax:

This method enables the following syntax:

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

This method enables the following syntax:

This method enables the following syntax:

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

This method enables the following syntax:

This method enables the following syntax:

all(xs) shouldBe an [Type]
       ^
infix def shouldBe[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) shouldBe 7
        ^
infix def shouldBe(comparison: ResultOfLessThanComparison[T]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

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

This method enables syntax such as the following:

This method enables syntax such as the following:

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

This method enables syntax such as the following:

This method enables syntax such as the following:

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

This method enables syntax such as the following:

This method enables syntax such as the following:

all(8, 9, 10) shouldBe >= (7)
             ^
infix def shouldBe(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) shouldBe odd
       ^
infix def shouldBe(spread: Spread[T]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

all(xs) shouldBe 7.1 +- 0.2
       ^
infix def shouldBe(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) shouldBe theSameInstanceAs (anotherObject)
       ^
infix def shouldBe(o: Null)(implicit ev: T <:< AnyRef): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) shouldBe null
       ^
infix def shouldBe[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) shouldBe excellentRead
       ^
infix def shouldBe[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) shouldBe a (goodRead)
       ^
infix def shouldBe[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) shouldBe an (excellentRead)
       ^
infix def shouldEqual(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) shouldEqual 7
        ^
infix def shouldEqual(spread: Spread[T]): Assertion

This method enables syntax such as the following:

This method enables syntax such as the following:

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

This method enables syntax such as the following:

This method enables syntax such as the following:

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

This method enables syntax such as the following:

This method enables syntax such as the following:

all(xs) shouldNot (be (3))
       ^
infix def shouldNot[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) shouldNot (equal (3))
       ^
infix def shouldNot(beWord: BeWord): ResultOfBeWordForCollectedAny[T]

This method enables the following syntax:

This method enables the following syntax:

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

This method enables syntax such as the following:

This method enables syntax such as the following:

all (xs) shouldNot contain (oneOf (1, 2, 3))
        ^
infix def shouldNot(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) shouldNot exist
       ^
infix def shouldNot(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) shouldNot fullyMatch regex ("""(-)?(\d+)(\.\d*)?""")
           ^
infix def shouldNot(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) shouldNot startWith regex ("Hel*o")
           ^
infix def shouldNot(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) shouldNot endWith regex ("wo.ld")
           ^
infix def shouldNot(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) shouldNot 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